Retire custom image after extension migration

513b8d68f5085d16f678c547682d5c038626f8fa

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

Parents: 1be11f8dd2d443b8eb5db77b5a9fdb8a7359eb06

.gitlab-ci.yml+0 -56 Viewed

-stages:
-  - build
-  - publish
-build-image:
-  stage: build
-  only:
-    - main
-  image: docker:latest
-  services:
-    - name: docker:dind
-      alias: docker
-      # DNS for nested containers comes from the runner's
-      # GITGUD_RUNNER_UPSTREAM_DNS. --bip avoids network collisions; --mtu
-      # clamps the inner bridge (PMTUD blackhole).
-      command: ["sh", "-c", "DOCKER_TLS_CERTDIR='' exec dockerd-entrypoint.sh --bip=192.168.255.1/24 --mtu=1400"]
-  variables:
-    DOCKER_HOST: tcp://docker:2375
-  script:
-    - for i in $(seq 1 60); do docker info >/dev/null 2>&1 && break; sleep 1; done
-    - docker info >/dev/null
-    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
-    - docker pull "$CI_REGISTRY_IMAGE:latest" || true
-    - docker build --cache-from "$CI_REGISTRY_IMAGE:latest" --label "org.opencontainers.image.source=$CI_PROJECT_URL" --label "org.opencontainers.image.revision=$CI_COMMIT_SHA" --label "org.opencontainers.image.created=$(date -u +%Y-%m-%dT%H:%M:%SZ)" -t "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA" -t "$CI_REGISTRY_IMAGE:latest" .
-    - docker push "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA"
-    - docker push "$CI_REGISTRY_IMAGE:latest"
-# Publishes the sillytavern npm package to this project's GitGudLab npm
-# registry on pushes to release, but only when package.json's version isn't
-# published yet. Authenticates with CI_JOB_TOKEN (accepted by the package
-# registry since gitgudlab 218062e — own project only, pusher needs Push);
-# an NPM_TOKEN project CI variable overrides it.
-publish-npm:
-  stage: publish
-  only:
-    - main
-  image: node:24
-  variables:
-    npm_config_cache: .npm
-    ST_NPM_REGISTRY: git.nas.home.htl-sky.net/api/v1/projects/permissionBRICK/SillyTavern/packages/npm/
-  cache:
-    # v2: the v1 cache accumulated each failed publish's own tarball
-    # (cacache doubles the package every run) — key bump discards it
-    key: npm-v2
-    paths:
-      - .npm
-  script:
-    - echo "//${ST_NPM_REGISTRY}:_authToken=${NPM_TOKEN:-$CI_JOB_TOKEN}" > .npmrc
-    - npm ci --omit=dev --ignore-scripts
-    - VERSION=$(node -p "require('./package.json').version")
-    - |
-      if npm view "sillytavern@${VERSION}" version --registry "https://${ST_NPM_REGISTRY}" >/dev/null 2>&1; then
-        echo "Version ${VERSION} is already published; nothing to do."
-        exit 0
-      fi
-    - npm publish --registry "https://${ST_NPM_REGISTRY}"

.npmignore+0 -3 Viewed

 /public/scripts/extensions/third-party
 /colab
 .gemini
-# CI npm cache lives in the workspace (npm_config_cache: .npm) — never pack it
-/.npm
-/.npmrc

README.md+1 -1 Viewed

 # SillyTavern
-LLM Frontend for Power Users - with a few additional features
+LLM Frontend for Power Users
 ## Resources

homelab/README.md+9 -8 Viewed

 | File | Deployed at | Purpose |
 |---|---|---|
 | `whisper-lazy-proxy.py` | `/mnt/user/appdata/whisper-lazy/proxy.py` (container `whisper-lazy`, :10300) | Wyoming lazy proxy: answers HA availability checks from cache, starts `faster-whisper` on demand, stops it after 15 min idle (frees GPU VRAM). |
-| `runpod-lazy-proxy.py` | `/mnt/user/appdata/runpod-lazy/proxy.py` (container `runpod-lazy`, :8189) | ComfyUI-compatible on-demand proxy for a volumeless RunPod GPU pod: only `/lazy/warmup` starts or provisions, while cold ComfyUI requests return 503 for provider failover. `/lazy/ping` records 20-second frontend heartbeats; the proxy owns the 60-second upstream keepalive cadence and continues it through browser timer pauses up to a 5-minute lease. A NAS-side idle timer terminates the pod 15 minutes after keepalives and other activity stop. Model-set changes requested by Warm up download in place via the worker image's model-manager (port 8189, LRU disk eviction); pods are only recreated when none exists or the image predates the manager. |
-| `runpod-pod.sh` | `/boot/config/runpod-pod.sh` | CLI for the runpod-lazy control API (`status|warmup|shutdown|ping|watch`). |
 | `unraid/my-sillytavern.xml` | `/boot/config/plugins/dockerMan/templates-user/my-sillytavern.xml` | Unraid template for the GitGudLab `:latest` image and persistent config/data/plugin mounts. |
 | `unraid/bootstrap-sillytavern.sh` | `/boot/config/bootstrap-sillytavern.sh` | Recovery bootstrap used when the container or DockerMan template is absent. |
 | `unraid/redeploy-sillytavern.sh` | `/boot/config/redeploy-sillytavern.sh` | Recreates the container through Unraid's own updater so template and update-state bookkeeping stay authoritative. |
+| `unraid/registry-autoupdate.sh` | `/boot/config/registry-autoupdate.sh` | Polls the configured container tags and invokes their Unraid-managed redeploy scripts when an image changes. |
 ## SillyTavern image deployment
-Every push to `main` builds the complete customized source tree in GitGudLab CI
+The NAS now runs the official stable release image,
-and publishes both the commit tag and
+`ghcr.io/sillytavern/sillytavern:latest`. permissionBRICK features live in
-`git.nas.home.htl-sky.net/permissionbrick/sillytavern:latest`. The image carries
+persistent public browser/server extensions instead of a custom image.
-OCI source, revision, and build-time labels so a running container can be tied
-back to the exact commit.
 On Unraid, Community Applications Auto Update has `sillytavern` enabled. A
-shared registry poller additionally checks the GitGudLab tag every two minutes
+shared registry poller additionally checks the official tag every two minutes
 and invokes `redeploy-sillytavern.sh` when its image ID changes. Do not point
 the DockerMan template at a different image while leaving that poller enabled:
 the poller and template would otherwise continually disagree and recreate the

 Related: the RunPod worker image (ComfyUI + custom nodes + boot-time model
 downloader) is built from github.com/permissionBRICK/comfyui-runpod-worker
 (private repo, public GHCR package; mirrored on this GitGudLab).
+The RunPod lazy proxy, CLI, tests, container image, and Unraid template moved to
+the public `permissionBRICK/ST-RunPodProxy` repository. Image Provider
+Extensions links to that service as its optional RunPod backend.

homelab/runpod-lazy-proxy.py+0 -587 Viewed

-#!/usr/bin/env python3
-"""ComfyUI lazy proxy for a volumeless RunPod on-demand pod (catalog edition).
-SillyTavern's fallback chain points at this proxy as a normal ComfyUI server.
-Models come from a CATALOG pushed by the ST UI: entries of
-  {"name": display, "value": model filename, "files": [{"dest": "unet/x.gguf", "url": "..."}]}
-The pod downloads exactly the selected entry's files at boot (boot-models.py
-reads MODEL_MANIFEST). Changing the active model with a RUNNING pod downloads
-the new files IN PLACE through the pod's model-manager (port 8189; LRU-evicts
-old models if the disk runs short) - the pod is only recreated when it runs an
-old image without the manager.
-Control API (CORS-enabled; ST warmup UI + runpod-pod.sh CLI):
-  GET  /lazy/status    -> {"state": red|orange|green, "model": ..., ...}
-  POST /lazy/warmup    -> start pod for the active catalog entry
-  POST /lazy/shutdown  -> terminate pod now
-  POST /lazy/ping      -> record a frontend heartbeat (never starts a pod)
-  POST /lazy/catalog   -> {"models": [...], "active": "<value>"} store catalog;
-                          never starts or provisions a pod
-Start semantics: only POST /lazy/warmup may provision or change models. ComfyUI
-requests return 503 unless a pod is already ready, allowing SillyTavern's image
-target fallback chain to continue without waking this target. Browser heartbeats
-grant a short lease during which this proxy sends keepalive probes on a stable
-backend cadence. The idle timer lives here (NAS side): IDLE_SECONDS after the
-last activity signal the pod is terminated, frontend or no frontend.
-"""
-import json
-import os
-import threading
-import time
-import urllib.error
-import urllib.request
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-RUNPOD_KEY = os.environ['RUNPOD_KEY']
-LISTEN_PORT = int(os.environ.get('LISTEN_PORT', '8189'))
-IDLE_SECONDS = int(os.environ.get('IDLE_SECONDS', '900'))
-KEEPALIVE_SECONDS = max(1, int(os.environ.get('KEEPALIVE_SECONDS', '60')))
-FRONTEND_LEASE_SECONDS = max(1, int(os.environ.get('FRONTEND_LEASE_SECONDS', '300')))
-DATACENTERS = [d for d in os.environ.get('DATACENTERS', '').split(',') if d]
-CLOUD_TYPE = os.environ.get('CLOUD_TYPE', 'SECURE')
-IMAGE = os.environ.get('IMAGE', 'ghcr.io/permissionbrick/comfyui-runpod-worker:latest')
-GPU_TYPES = os.environ.get('GPU_TYPES', 'NVIDIA RTX 6000 Ada Generation,NVIDIA L40S,NVIDIA L40,NVIDIA RTX A6000,NVIDIA A40').split(',')
-# The worker image runs the cu12.8 runtime; hosts with older drivers fail at
-# sampling time with "CUDA driver version is insufficient" (host lottery).
-CUDA_VERSIONS = [v for v in os.environ.get('CUDA_VERSIONS', '12.8,12.9,13.0').split(',') if v]
-POD_NAME = os.environ.get('POD_NAME', 'comfyui-lazy')
-START_TIMEOUT = int(os.environ.get('START_TIMEOUT', '1500'))
-HF_TOKEN = os.environ.get('HF_TOKEN', '')
-COMFY_ARGS = os.environ.get('COMFY_ARGS', '--listen 0.0.0.0 --port 8188 --use-pytorch-cross-attention')
-CATALOG_FILE = os.environ.get('CATALOG_FILE', '/app/catalog.json')
-state = {
-    'pod_id': None,
-    'model': None,      # values_key of the models the pod holds
-    'phase': 'red',     # red | orange | green
-    'gpu': None,
-    'since': time.time(),
-    'last': time.monotonic(),
-    'frontend_last_seen': None,
-    'keepalive_last': None,
-    'ensuring': 0,      # active ensure_pod waiters (status skips probing then)
-    'control_epoch': 0, # incremented by shutdown to cancel in-flight warmups
-    'lock': threading.Lock(),
-}
-def log(*args):
-    print(time.strftime('%H:%M:%S'), *args, flush=True)
-def load_catalog():
-    try:
-        with open(CATALOG_FILE) as f:
-            return json.load(f)
-    except Exception:
-        return {'models': [], 'active': None}
-def save_catalog(catalog):
-    with open(CATALOG_FILE, 'w') as f:
-        json.dump(catalog, f, indent=2)
-def catalog_entry(value):
-    if not value:
-        return None
-    for entry in load_catalog().get('models', []):
-        if entry.get('value') == value:
-            return entry
-    return None
-def active_values():
-    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 key_values(key):
-    return set(k for k in (key or '').split('+') if k)
-def needed_files(values):
-    files = []
-    for value in values or []:
-        entry = catalog_entry(value)
-        if entry:
-            files.extend(entry.get('files') or [])
-    return files
-def all_catalog_files():
-    files = []
-    for entry in load_catalog().get('models', []):
-        files.extend(entry.get('files') or [])
-    return files
-def prefetch_rest(pod_id):
-    """Queues every catalog file on the pod (background, non-priority) so later
-    model switches find the files already on disk."""
-    files = all_catalog_files()
-    if not files:
-        return
-    try:
-        res = mm_request(pod_id, 'POST', '/ensure', {'files': files}, timeout=20)
-        if res.get('queued'):
-            log('background prefetch queued:', ', '.join(res['queued']))
-    except Exception:
-        pass  # old image without a model manager
-def api(method, path, body=None):
-    req = urllib.request.Request(
-        f'https://rest.runpod.io/v1{path}',
-        json.dumps(body).encode() if body is not None else None,
-        {'Authorization': f'Bearer {RUNPOD_KEY}', 'Content-Type': 'application/json'},
-        method=method)
-    with urllib.request.urlopen(req, timeout=60) as resp:
-        data = resp.read()
-        return json.loads(data) if data else {}
-def find_pod():
-    try:
-        for pod in api('GET', '/pods'):
-            if pod.get('name') == POD_NAME and pod.get('desiredStatus') == 'RUNNING':
-                env = pod.get('env') or {}
-                return pod['id'], env.get('MODEL_KEY'), pod.get('machine', {}).get('gpuTypeId')
-    except Exception as err:
-        log('find_pod failed:', err)
-    return None, None, None
-def create_pod(values, datacenters=None):
-    files = []
-    for value in values or []:
-        entry = catalog_entry(value)
-        if entry:
-            files.extend(entry.get('files') or [])
-    env = {'HF_TOKEN': HF_TOKEN, 'CIVITAI_TOKEN': os.environ.get('CIVITAI_TOKEN', ''), 'GITHUB_TOKEN': os.environ.get('GITHUB_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 = {
-        'name': POD_NAME,
-        'imageName': IMAGE,
-        'gpuTypeIds': GPU_TYPES,
-        'gpuCount': 1,
-        'cloudType': CLOUD_TYPE,
-        'containerDiskInGb': 80,
-        'ports': ['8188/http', '8189/http'],
-        'env': env,
-        # Manager starts FIRST so boot download progress is visible from
-        # outside; the subshell tolerates old images without the script.
-        'dockerStartCmd': ['bash', '-c', f'(python3 /model-manager.py &) ; python3 /boot-models.py && cd /comfyui && exec python main.py {COMFY_ARGS}'],
-    }
-    if datacenters:
-        body['dataCenterIds'] = datacenters
-    if CUDA_VERSIONS:
-        body['allowedCudaVersions'] = CUDA_VERSIONS
-    pod = api('POST', '/pods', body)
-    log(f"pod created: {pod['id']} models={values_key(values) or 'legacy-all'} {pod.get('machine', {}).get('gpuTypeId')} ${pod.get('costPerHr')}/hr dc={pod.get('machine', {}).get('dataCenterId') or (','.join(datacenters) if datacenters else 'any')}")
-    return pod['id'], pod.get('machine', {}).get('gpuTypeId')
-def pod_url(pod_id):
-    return f'https://{pod_id}-8188.proxy.runpod.net'
-def mm_request(pod_id, method, path, obj=None, timeout=15):
-    """Calls the in-pod model manager (port 8189)."""
-    req = urllib.request.Request(
-        f'https://{pod_id}-8189.proxy.runpod.net{path}',
-        json.dumps(obj).encode() if obj is not None else None,
-        {'User-Agent': UA, 'Content-Type': 'application/json'},
-        method=method)
-    with urllib.request.urlopen(req, timeout=timeout) as resp:
-        return json.loads(resp.read() or b'{}')
-UA = 'Mozilla/5.0 (compatible; runpod-lazy-proxy)'
-def upstream_ready(pod_id):
-    try:
-        req = urllib.request.Request(pod_url(pod_id) + '/system_stats', headers={'User-Agent': UA})
-        with urllib.request.urlopen(req, timeout=5) as resp:
-            if resp.status == 200:
-                resp.read()
-                return True
-    except Exception:
-        pass
-    return False
-def terminate(pod_id):
-    try:
-        api('DELETE', f'/pods/{pod_id}')
-        log('pod terminated:', pod_id)
-    except Exception as err:
-        log('terminate failed:', err)
-def _create_pod_with_retries(values):
-    state['phase'] = 'orange'
-    state['since'] = time.time()
-    last_err = None
-    # Prefer the DATACENTERS list (e.g. US - fast HuggingFace peering for model
-    # downloads); if it has no capacity, fall back to any datacenter.
-    plans = [DATACENTERS, DATACENTERS, None] if DATACENTERS else [None, None, None]
-    for attempt, datacenters in enumerate(plans):
-        try:
-            return create_pod(values, datacenters)
-        except urllib.error.HTTPError as err:
-            last_err = err.read().decode()[:200]
-            scope = 'preferred DCs' if datacenters else 'global'
-            log(f'create_pod attempt {attempt + 1} ({scope}) failed:', last_err)
-            time.sleep(5)
-    state['phase'] = 'red'
-    raise RuntimeError(f'could not create pod: {last_err}')
-def ensure_pod(values=None, wait=True, control_epoch=None):
-    """Ensures a pod holding the catalog values (None = active selection).
-    An existing pod gets missing models downloaded IN PLACE through the in-pod
-    model manager; recreation only happens for old-image pods without one."""
-    def check_cancelled():
-        if control_epoch is not None and control_epoch != state['control_epoch']:
-            raise RuntimeError('pod warmup cancelled')
-    values = values or active_values()
-    key = values_key(values)
-    files = needed_files(values)
-    dests = [f['dest'].lstrip('/') for f in files]
-    created = False
-    with state['lock']:
-        check_cancelled()
-        pod_id, have, gpu = (state['pod_id'], state['model'], state['gpu'])
-        if not pod_id:
-            pod_id, have, gpu = find_pod()
-        if not pod_id:
-            pod_id, gpu = _create_pod_with_retries(values)
-            have, created = key, True
-        check_cancelled()
-        state.update({
-            'pod_id': pod_id,
-            'model': have,
-            'gpu': gpu,
-            'last': time.monotonic(),
-            'phase': 'green' if state['phase'] == 'green' else 'orange',
-        })
-    if not wait:
-        return pod_id
-    # Freshly created pods boot with the right manifest; existing pods need an
-    # /ensure pushed once the manager answers.
-    ensured = created or not files
-    no_manager_strikes = 0
-    with state['lock']:
-        check_cancelled()
-        state['ensuring'] += 1
-    try:
-        deadline = time.monotonic() + START_TIMEOUT
-        while time.monotonic() < deadline:
-            # Booting/downloading counts as activity, else the reaper would
-            # kill a warming pod mid-download.
-            with state['lock']:
-                check_cancelled()
-                if state['pod_id'] != pod_id:
-                    raise RuntimeError('pod replaced while waiting')
-                state['last'] = time.monotonic()
-            if not ensured:
-                try:
-                    mm_request(pod_id, 'POST', '/ensure', {'files': files, 'priority': True})
-                except Exception:
-                    pass  # manager still booting, or old image without one
-                else:
-                    ensured = True
-                    with state['lock']:
-                        check_cancelled()
-                        state['model'] = values_key(key_values(state['model']) | set(values))
-                    log(f'in-place ensure requested: {key}')
-            ready = upstream_ready(pod_id)
-            models_ok = True
-            if not created and files and ensured:
-                try:
-                    mm = mm_request(pod_id, 'GET', '/status', timeout=10)
-                    errs = {d: e for d, e in (mm.get('errors') or {}).items() if d in dests}
-                    if errs:
-                        raise RuntimeError(f'model download failed: {errs}')
-                    models_ok = not (set(dests) - set(mm.get('present') or []))
-                except RuntimeError:
-                    raise
-                except Exception:
-                    models_ok = False
-            if ready and not ensured:
-                no_manager_strikes += 1
-            if (no_manager_strikes >= 3 and key and state['model'] and state['model'] != key):
-                # Comfy is up but there is no manager (old image): last resort.
-                log(f'pod has models={state["model"]}, need {key} - recreating (no model manager)')
-                with state['lock']:
-                    check_cancelled()
-                    terminate(pod_id)
-                    pod_id, gpu = _create_pod_with_retries(values)
-                    check_cancelled()
-                    state.update({'pod_id': pod_id, 'model': key, 'gpu': gpu, 'last': time.monotonic()})
-                created, ensured = True, True
-                continue
-            if ready and models_ok:
-                with state['lock']:
-                    check_cancelled()
-                    if state['pod_id'] != pod_id:
-                        raise RuntimeError('pod replaced while waiting')
-                    if state['phase'] != 'green':
-                        state['phase'] = 'green'
-                        state['since'] = time.time()
-                        log('pod ready:', pod_id)
-                    # Green on the needed set; everything else in the catalog
-                    # downloads in the background for instant later switches.
-                    if state.get('prefetch_pod') != pod_id:
-                        state['prefetch_pod'] = pod_id
-                        threading.Thread(target=prefetch_rest, args=(pod_id,), daemon=True).start()
-                return pod_id
-            with state['lock']:
-                check_cancelled()
-                if state['phase'] == 'green':
-                    state['phase'] = 'orange'  # in-place download in progress
-                if state['pod_id'] != pod_id:
-                    raise RuntimeError('pod replaced while waiting')
-            time.sleep(5)
-        raise RuntimeError('pod not ready within START_TIMEOUT')
-    finally:
-        with state['lock']:
-            state['ensuring'] -= 1
-def idle_reaper():
-    while True:
-        time.sleep(30)
-        idle = time.monotonic() - state['last']
-        if idle > IDLE_SECONDS:
-            # A heartbeat may arrive just before the next scheduled backend
-            # probe. Its live lease protects the pod until that probe catches
-            # up, without relying on the browser to refresh the idle clock.
-            if frontend_lease_seconds_left() > 0:
-                continue
-            pod_id = state['pod_id'] or find_pod()[0]
-            if pod_id:
-                log(f'idle {int(idle)}s - terminating pod')
-                terminate(pod_id)
-            if pod_id or state['phase'] != 'red':
-                state.update({'pod_id': None, 'model': None, 'gpu': None, 'phase': 'red', 'since': time.time()})
-def frontend_lease_seconds_left(now=None):
-    """Returns the remaining frontend heartbeat lease in whole seconds."""
-    now = time.monotonic() if now is None else now
-    last_seen = state['frontend_last_seen']
-    if last_seen is None:
-        return 0
-    return max(0, FRONTEND_LEASE_SECONDS - int(now - last_seen))
-def maintain_frontend_keepalive(now=None):
-    """Probes and refreshes a ready pod while a frontend heartbeat lease is live."""
-    now = time.monotonic() if now is None else now
-    with state['lock']:
-        pod_id = state['pod_id']
-        lease_active = frontend_lease_seconds_left(now) > 0
-        ready = state['phase'] == 'green' and state['ensuring'] == 0
-    if not pod_id or not lease_active or not ready or not upstream_ready(pod_id):
-        return False
-    with state['lock']:
-        # The network probe runs outside the lock. Re-check that its result still
-        # belongs to the current pod and a still-live frontend lease.
-        if state['pod_id'] != pod_id or frontend_lease_seconds_left(now) <= 0:
-            return False
-        state['last'] = now
-        state['keepalive_last'] = now
-    return True
-def keepalive_scheduler():
-    """Runs keepalive probes on a monotonic backend cadence without timer drift."""
-    next_tick = time.monotonic() + KEEPALIVE_SECONDS
-    while True:
-        time.sleep(max(0, next_tick - time.monotonic()))
-        maintain_frontend_keepalive()
-        next_tick += KEEPALIVE_SECONDS
-        now = time.monotonic()
-        if next_tick <= now:
-            # Skip missed ticks after a long process pause instead of issuing a
-            # burst of stale keepalives, while keeping future ticks aligned.
-            missed = int((now - next_tick) // KEEPALIVE_SECONDS) + 1
-            next_tick += missed * KEEPALIVE_SECONDS
-def status_body():
-    pod_id = state['pod_id']
-    previous_phase = state['phase']
-    if state['ensuring'] > 0:
-        # An ensure_pod waiter owns the phase; probing here could report green
-        # mid-download or block the status reply on a dead pod's proxy URL.
-        pass
-    elif pod_id:
-        if upstream_ready(pod_id):
-            state['phase'] = 'green'
-        else:
-            found, have, gpu = find_pod()
-            if found:
-                state.update({'pod_id': found, 'model': have, 'gpu': gpu, 'phase': 'orange'})
-            else:
-                state.update({'pod_id': None, 'model': None, 'gpu': None, 'phase': 'red'})
-        if state['phase'] == 'green' and previous_phase != 'green':
-            state['since'] = time.time()
-    else:
-        found, have, gpu = find_pod()
-        if found:
-            state.update({'pod_id': found, 'model': have, 'gpu': gpu})
-            state['phase'] = 'green' if upstream_ready(found) else 'orange'
-        elif state['phase'] != 'orange':
-            state['phase'] = 'red'
-    return json.dumps({
-        'state': state['phase'],
-        'pod_id': state['pod_id'],
-        'model': state['model'],
-        'active': active_values(),
-        'gpu': state['gpu'],
-        'since': state['since'],
-        'url': pod_url(state['pod_id']) if state['pod_id'] else None,
-        'idle_seconds_left': max(0, IDLE_SECONDS - int(time.monotonic() - state['last'])) if state['pod_id'] else 0,
-        'frontend_lease_seconds_left': frontend_lease_seconds_left(),
-        'keepalive_active': bool(state['pod_id'] and state['phase'] == 'green' and frontend_lease_seconds_left() > 0),
-    }).encode()
-class Proxy(BaseHTTPRequestHandler):
-    protocol_version = 'HTTP/1.1'
-    def log_message(self, fmt, *args):
-        pass
-    def _reply(self, code, data, ctype='application/json'):
-        self.send_response(code)
-        self.send_header('Content-Type', ctype or 'application/json')
-        self.send_header('Content-Length', str(len(data)))
-        self.send_header('Access-Control-Allow-Origin', '*')
-        self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
-        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
-        self.end_headers()
-        self.wfile.write(data)
-    def do_OPTIONS(self):
-        self._reply(204, b'')
-    def _handle(self):
-        length = int(self.headers.get('Content-Length') or 0)
-        body = self.rfile.read(length) if length else None
-        path = self.path.split('?')[0]
-        # ---- control API ----
-        if path == '/lazy/status':
-            if self.command != 'GET':
-                return self._reply(405, b'{"error": "method not allowed"}')
-            return self._reply(200, status_body())
-        if path in ('/lazy/ping', '/lazy/warmup', '/lazy/shutdown', '/lazy/catalog') and self.command != 'POST':
-            return self._reply(405, b'{"error": "method not allowed"}')
-        if path == '/lazy/ping':
-            with state['lock']:
-                state['frontend_last_seen'] = time.monotonic()
-            return self._reply(200, b'{"ok": true}')
-        if path == '/lazy/warmup':
-            with state['lock']:
-                control_epoch = state['control_epoch']
-                if state['phase'] != 'green':
-                    state['phase'] = 'orange'
-            threading.Thread(target=self._safe_ensure, args=(None, control_epoch), daemon=True).start()
-            return self._reply(200, status_body())
-        if path == '/lazy/shutdown':
-            # Serialize with pod creation/recreation. Incrementing the epoch
-            # also cancels a warmup thread that has not entered its lock yet.
-            with state['lock']:
-                state['control_epoch'] += 1
-                pod_id = state['pod_id'] or find_pod()[0]
-                if pod_id:
-                    terminate(pod_id)
-                state.update({'pod_id': None, 'model': None, 'gpu': None, 'phase': 'red', 'since': time.time()})
-            return self._reply(200, status_body())
-        if path == '/lazy/catalog':
-            try:
-                payload = json.loads(body or b'{}')
-                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']}")
-                return self._reply(200, status_body())
-            except Exception as err:
-                return self._reply(400, json.dumps({'error': str(err)}).encode())
-        # ---- comfy proxying ----
-        pod_id = state['pod_id']
-        if not pod_id:
-            pod_id, have, gpu = find_pod()
-            if pod_id:
-                state.update({'pod_id': pod_id, 'model': have, 'gpu': gpu, 'phase': 'orange'})
-        ready = pod_id and state['ensuring'] == 0 and upstream_ready(pod_id)
-        if not ready:
-            return self._reply(503, json.dumps({
-                'error': 'RunPod pod is not ready; start it with SillyTavern\'s Warm up control.',
-            }).encode())
-        if state['phase'] != 'green':
-            state.update({'phase': 'green', 'since': time.time()})
-        state['last'] = time.monotonic()
-        try:
-            req = urllib.request.Request(pod_url(pod_id) + self.path, body, method=self.command)
-            req.add_header('User-Agent', UA)
-            for header in ('Content-Type', 'Accept'):
-                if self.headers.get(header):
-                    req.add_header(header, self.headers[header])
-            with urllib.request.urlopen(req, timeout=300) as resp:
-                self._reply(resp.status, resp.read(), resp.headers.get('Content-Type'))
-        except urllib.error.HTTPError as err:
-            self._reply(err.code, err.read())
-        except Exception as err:
-            log('upstream error:', err)
-            self._reply(502, json.dumps({'error': str(err)}).encode())
-        finally:
-            state['last'] = time.monotonic()
-    def _safe_ensure(self, value, control_epoch):
-        try:
-            ensure_pod(value, control_epoch=control_epoch)
-        except Exception as err:
-            log('provision failed:', err)
-    do_GET = _handle
-    do_POST = _handle
-def main():
-    threading.Thread(target=idle_reaper, daemon=True).start()
-    threading.Thread(target=keepalive_scheduler, daemon=True).start()
-    # Adopt a pre-existing pod after a proxy restart without provisioning or
-    # changing it. Read-only status polls will update its readiness phase.
-    pod_id, have, gpu = find_pod()
-    if pod_id:
-        state.update({'pod_id': pod_id, 'model': have, 'gpu': gpu, 'phase': 'orange', 'last': time.monotonic()})
-        log(f'adopting existing pod {pod_id} (model={have})')
-    server = ThreadingHTTPServer(('0.0.0.0', LISTEN_PORT), Proxy)
-    log(f'runpod-lazy v6 (manual warmup only) on :{LISTEN_PORT} (pod "{POD_NAME}", DCs {DATACENTERS or "any"}, idle {IDLE_SECONDS}s)')
-    server.serve_forever()
-if __name__ == '__main__':
-    main()

homelab/runpod-pod.sh+0 -15 Viewed

-#!/bin/sh
-# CLI for the runpod-lazy proxy: status | warmup | shutdown | ping (renew frontend lease)
-# Usable by anyone (or any AI) without SillyTavern. Proxy owns the pod
-# lifecycle; this only talks to its control API.
-CMD="${1:-status}"
-URL="${RUNPOD_LAZY_URL:-http://127.0.0.1:8189}"
-case "$CMD" in
-  status)   curl -s "$URL/lazy/status" ;;
-  warmup)   curl -s -X POST "$URL/lazy/warmup" ;;
-  shutdown) curl -s -X POST "$URL/lazy/shutdown" ;;
-  ping)     curl -s -X POST "$URL/lazy/ping" ;;
-  watch)    while true; do printf '%s ' "$(date +%H:%M:%S)"; curl -s "$URL/lazy/status"; echo; sleep 10; done ;;
-  *) echo "usage: runpod-pod.sh [status|warmup|shutdown|ping|watch]"; exit 1 ;;
-esac
-echo

homelab/tests/test_runpod_lazy_proxy.py+0 -197 Viewed

-import http.client
-import importlib.util
-import json
-import os
-import pathlib
-import tempfile
-import threading
-import unittest
-from unittest import mock
-os.environ.setdefault('RUNPOD_KEY', 'test-key')
-PROXY_PATH = pathlib.Path(__file__).parents[1] / 'runpod-lazy-proxy.py'
-SPEC = importlib.util.spec_from_file_location('runpod_lazy_proxy', PROXY_PATH)
-proxy = importlib.util.module_from_spec(SPEC)
-SPEC.loader.exec_module(proxy)
-class RunpodLazyProxyTest(unittest.TestCase):
-    def setUp(self):
-        self.temp_dir = tempfile.TemporaryDirectory()
-        proxy.CATALOG_FILE = str(pathlib.Path(self.temp_dir.name) / 'catalog.json')
-        proxy.state.update({
-            'pod_id': None,
-            'model': None,
-            'phase': 'red',
-            'gpu': None,
-            'since': 0,
-            'last': 100,
-            'frontend_last_seen': None,
-            'keepalive_last': None,
-            'ensuring': 0,
-            'control_epoch': 0,
-        })
-        self.find_pod = mock.patch.object(proxy, 'find_pod', return_value=(None, None, None))
-        self.find_pod_mock = self.find_pod.start()
-        self.server = proxy.ThreadingHTTPServer(('127.0.0.1', 0), proxy.Proxy)
-        self.server_thread = threading.Thread(target=self.server.serve_forever, daemon=True)
-        self.server_thread.start()
-    def tearDown(self):
-        self.server.shutdown()
-        self.server.server_close()
-        self.server_thread.join()
-        self.find_pod.stop()
-        self.temp_dir.cleanup()
-    def request(self, method, path, payload=None):
-        body = json.dumps(payload) if payload is not None else None
-        headers = {'Content-Type': 'application/json'} if body is not None else {}
-        connection = http.client.HTTPConnection('127.0.0.1', self.server.server_port, timeout=2)
-        connection.request(method, path, body=body, headers=headers)
-        response = connection.getresponse()
-        data = response.read()
-        connection.close()
-        return response.status, json.loads(data or b'{}')
-    def test_cold_comfy_requests_fail_without_provisioning(self):
-        with mock.patch.object(proxy, 'ensure_pod') as ensure_pod:
-            for method, path, payload in [
-                ('GET', '/system_stats', None),
-                ('GET', '/object_info', None),
-                ('POST', '/prompt', {'prompt': {}}),
-            ]:
-                with self.subTest(path=path):
-                    status, body = self.request(method, path, payload)
-                    self.assertEqual(status, 503)
-                    self.assertIn('Warm up', body['error'])
-            ensure_pod.assert_not_called()
-    def test_status_ping_and_catalog_do_not_provision_cold_pod(self):
-        with mock.patch.object(proxy, 'ensure_pod') as ensure_pod:
-            status, body = self.request('GET', '/lazy/status')
-            self.assertEqual(status, 200)
-            self.assertEqual(body['state'], 'red')
-            with mock.patch.object(proxy.time, 'monotonic', return_value=120):
-                status, _ = self.request('POST', '/lazy/ping')
-            self.assertEqual(status, 200)
-            self.assertEqual(proxy.state['last'], 100)
-            self.assertEqual(proxy.state['frontend_last_seen'], 120)
-            catalog = {
-                'models': [{'name': 'Test', 'value': 'test.safetensors', 'files': []}],
-                'active': ['test.safetensors'],
-            }
-            status, _ = self.request('POST', '/lazy/catalog', catalog)
-            self.assertEqual(status, 200)
-            self.assertEqual(proxy.load_catalog(), catalog)
-            ensure_pod.assert_not_called()
-    def test_status_clears_a_stale_ready_pod_without_restarting_it(self):
-        proxy.state.update({'pod_id': 'stopped-pod', 'phase': 'green', 'last': 100})
-        with mock.patch.object(proxy, 'upstream_ready', return_value=False):
-            status, body = self.request('GET', '/lazy/status')
-        self.assertEqual(status, 200)
-        self.assertEqual(body['state'], 'red')
-        self.assertIsNone(body['pod_id'])
-        status, _ = self.request('POST', '/lazy/ping')
-        self.assertEqual(status, 200)
-        self.assertEqual(proxy.state['last'], 100)
-    def test_backend_maintains_keepalive_during_frontend_lease(self):
-        proxy.state.update({
-            'pod_id': 'ready-pod',
-            'phase': 'green',
-            'last': 100,
-            'frontend_last_seen': 100,
-        })
-        with mock.patch.object(proxy, 'upstream_ready', return_value=True) as upstream_ready:
-            maintained = proxy.maintain_frontend_keepalive(now=399)
-        self.assertTrue(maintained)
-        self.assertEqual(proxy.state['last'], 399)
-        self.assertEqual(proxy.state['keepalive_last'], 399)
-        upstream_ready.assert_called_once_with('ready-pod')
-    def test_backend_stops_keepalive_after_frontend_lease_expires(self):
-        proxy.state.update({
-            'pod_id': 'ready-pod',
-            'phase': 'green',
-            'last': 100,
-            'frontend_last_seen': 100,
-        })
-        with mock.patch.object(proxy, 'upstream_ready') as upstream_ready:
-            maintained = proxy.maintain_frontend_keepalive(now=401)
-        self.assertFalse(maintained)
-        self.assertEqual(proxy.state['last'], 100)
-        self.assertIsNone(proxy.state['keepalive_last'])
-        upstream_ready.assert_not_called()
-    def test_get_warmup_is_rejected_without_provisioning(self):
-        with mock.patch.object(proxy, 'ensure_pod') as ensure_pod:
-            status, body = self.request('GET', '/lazy/warmup')
-            self.assertEqual(status, 405)
-            self.assertEqual(body['error'], 'method not allowed')
-            ensure_pod.assert_not_called()
-    def test_warmup_is_the_explicit_provisioning_path(self):
-        called = threading.Event()
-        with mock.patch.object(proxy, 'ensure_pod') as ensure_pod:
-            ensure_pod.side_effect = lambda _value, control_epoch: called.set()
-            status, body = self.request('POST', '/lazy/warmup')
-            self.assertEqual(status, 200)
-            self.assertEqual(body['state'], 'orange')
-            self.assertTrue(called.wait(1))
-            ensure_pod.assert_called_once_with(None, control_epoch=0)
-    def test_shutdown_cancels_pod_creation_in_progress(self):
-        create_started = threading.Event()
-        finish_create = threading.Event()
-        shutdown_finished = threading.Event()
-        shutdown_result = {}
-        def create_pod(_values):
-            create_started.set()
-            self.assertTrue(finish_create.wait(2))
-            return 'created-after-warmup', 'test-gpu'
-        def shutdown_request():
-            shutdown_result['response'] = self.request('POST', '/lazy/shutdown')
-            shutdown_finished.set()
-        with mock.patch.object(proxy, '_create_pod_with_retries', side_effect=create_pod), \
-                mock.patch.object(proxy, 'terminate') as terminate:
-            status, body = self.request('POST', '/lazy/warmup')
-            self.assertEqual(status, 200)
-            self.assertEqual(body['state'], 'orange')
-            self.assertTrue(create_started.wait(1))
-            shutdown_thread = threading.Thread(target=shutdown_request)
-            shutdown_thread.start()
-            self.assertFalse(shutdown_finished.wait(0.1))
-            finish_create.set()
-            shutdown_thread.join(2)
-            self.assertFalse(shutdown_thread.is_alive())
-            status, body = shutdown_result['response']
-            self.assertEqual(status, 200)
-            self.assertEqual(body['state'], 'red')
-            self.assertIsNone(proxy.state['pod_id'])
-            terminate.assert_called_once_with('created-after-warmup')
-if __name__ == '__main__':
-    unittest.main()

homelab/unraid/bootstrap-sillytavern.sh+1 -1 Viewed

 # Raw recovery bootstrap. Normal updates go through redeploy-sillytavern.sh.
 set -eu
-REF=git.nas.home.htl-sky.net/permissionbrick/sillytavern:latest
+REF=ghcr.io/sillytavern/sillytavern:latest
 docker pull "$REF"
 docker rm -f sillytavern >/dev/null 2>&1 || true

homelab/unraid/my-sillytavern.xml+5 -5 Viewed

 <?xml version="1.0"?>
 <Container version="2">
   <Name>sillytavern</Name>
-  <Repository>git.nas.home.htl-sky.net/permissionbrick/sillytavern:latest</Repository>
+  <Repository>ghcr.io/sillytavern/sillytavern:latest</Repository>
-  <Registry>https://git.nas.home.htl-sky.net/permissionBRICK/SillyTavern</Registry>
+  <Registry>https://github.com/SillyTavern/SillyTavern/pkgs/container/sillytavern</Registry>
   <Network>bridge</Network>
   <MyIP/>
   <MyMAC/>
   <Shell>sh</Shell>
   <Privileged>false</Privileged>
   <Support>https://github.com/SillyTavern/SillyTavern/issues</Support>
-  <Project>https://git.nas.home.htl-sky.net/permissionBRICK/SillyTavern</Project>
+  <Project>https://github.com/SillyTavern/SillyTavern</Project>
-  <ReadMe>https://git.nas.home.htl-sky.net/permissionBRICK/SillyTavern</ReadMe>
+  <ReadMe>https://github.com/SillyTavern/SillyTavern</ReadMe>
-  <Overview>Full permissionBRICK SillyTavern build from GitGudLab, including RunPod/ComfyUI workflows, image references, OpenRouter per-chat session stickiness, and custom features not yet extracted as extensions. Public third-party extensions remain installed in the persistent user data directory. GitGudLab CI publishes :latest and Unraid automatically pulls and redeploys it.</Overview>
+  <Overview>Official SillyTavern release image. permissionBRICK features are installed as persistent public UI/server extensions, so Unraid can update the base application directly from the upstream :latest image.</Overview>
   <Category>Tools:</Category>
   <WebUI>http://nas.home.htl-sky.net:8000/</WebUI>
   <TemplateURL/>

homelab/unraid/registry-autoupdate.sh+34 -0 Viewed

+#!/bin/sh
+# Instant auto-update: poll the registry and redeploy a container as soon as
+# its published image differs from what is running. Cron runs this every 2 min
+# (/boot/config/plugins/dynamix/registry-autoupdate.cron).
+# Skips entirely while a CI job container is active: recreating gitgudlab would
+# kill the registry mid-push, and the runner must not recreate itself mid-job
+# (redeploy-gitgudlab-runner.sh also guards this itself).
+LOCK=/var/run/registry-autoupdate.lock
+mkdir "$LOCK" 2>/dev/null || exit 0
+trap 'rmdir "$LOCK"' EXIT
+if docker ps --format '{{.Names}}' | grep -q '^gitgud-job-'; then
+  exit 0
+fi
+check() {
+  name=$1; ref=$2; script=$3
+  docker pull -q "$ref" >/dev/null 2>&1 || return 0
+  latest=$(docker image inspect --format '{{.Id}}' "$ref" 2>/dev/null) || return 0
+  running=$(docker inspect --format '{{.Image}}' "$name" 2>/dev/null)
+  if [ "$latest" != "$running" ]; then
+    logger -t registry-autoupdate "updating $name ($running -> $latest)"
+    if sh "$script" >/dev/null 2>&1; then
+      logger -t registry-autoupdate "$name updated"
+    else
+      logger -t registry-autoupdate "$name redeploy failed or refused, will retry"
+    fi
+  fi
+}
+check gitgudlab git.nas.home.htl-sky.net/permissionbrick/gitgudlab:latest /boot/config/redeploy-gitgudlab.sh
+check gitgudlab-runner git.nas.home.htl-sky.net/permissionbrick/gitgudlab:runner-latest /boot/config/redeploy-gitgudlab-runner.sh
+check sillytavern ghcr.io/sillytavern/sillytavern:latest /boot/config/redeploy-sillytavern.sh

public/script.js+3 -35 Viewed

  * @property {string} [quietName] Name to use for the quiet prompt (defaults to "System:")
  * @property {number} [depth] Recursion depth for the generation. Used to prevent infinite loops in tool calls.
  * @property {JsonSchema} [jsonSchema] JSON schema to use for the structured generation. Usually requires a special instruction.
- * @property {boolean} [squashSystemMessages] Apply the configured system-message squashing during a dry run.
  */
 /**

  * @param {boolean} dryRun Whether to actually generate a message or just assemble the prompt
  * @returns {Promise<any>} Returns a promise that resolves when the text is done generating.
  */
-export async function Generate(type, { automatic_trigger, force_name2, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage, quietName, jsonSchema = null, depth = 0, squashSystemMessages = false } = {}, dryRun = false) {
+export async function Generate(type, { automatic_trigger, force_name2, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage, quietName, jsonSchema = null, depth = 0 } = {}, dryRun = false) {
     console.log('Generate entered');
     setGenerationProgress(0);
     generation_started = new Date();

                 jailbreakPromptOverride: jailbreak,
                 messages: oaiMessages,
                 messageExamples: oaiMessageExamples,
-                squashSystemMessages,
             }, dryRun);
             generate_data = { prompt: prompt };

         return Promise.resolve();
+    }
-    let activeProviderRequest = null;
-    async function beginProviderRequest() {
-        activeProviderRequest = {
-            id: uuidv4(),
-            type,
-            startedAt: Date.now(),
-        };
-        await eventSource.emit(event_types.GENERATION_REQUEST_STARTED, activeProviderRequest);
-    }
-    async function finishProviderRequest(success) {
-        if (!activeProviderRequest) {
-            return;
-        }
-        const request = activeProviderRequest;
-        activeProviderRequest = null;
-        await eventSource.emit(event_types.GENERATION_REQUEST_FINISHED, {
-            ...request,
-            success: !!success,
-            finishedAt: Date.now(),
-        });
-    }
     /**
      * Saves itemized prompt bits and calls streaming or non-streaming generation API.
      * @returns {Promise<void|*|Awaited<*>|String|{fromStream}|string|undefined|Object>}

                 streamingProcessor.firstMessageText = '';
+            }
-            await beginProviderRequest();
             streamingProcessor.generator = await sendStreamingRequest(type, generate_data, { jsonSchema });
             hideSwipeButtons();

             const isStreamFinished = streamingProcessor && !streamingProcessor.isStopped && streamingProcessor.isFinished;
             const isStreamWithToolCalls = streamingProcessor && Array.isArray(streamingProcessor.toolCalls) && streamingProcessor.toolCalls.length;
-            await finishProviderRequest(isStreamFinished);
             if (canPerformToolCalls && isStreamFinished && isStreamWithToolCalls) {
                 const lastMessage = chat[chat.length - 1];
                 const hasToolCalls = ToolManager.hasToolCalls(streamingProcessor.toolCalls);

@@ -5415,10 +5387,7 @@ export async function Generate(type, { automatic_trigger, force_name2, quiet_pro
5415	});	5387	});
5416	}	5388	}
5417	} else {	5389	} else {
5418	await beginProviderRequest();	5390	return await sendGenerationRequest(type, generate_data, { jsonSchema });
5419	const data = await sendGenerationRequest(type, generate_data, { jsonSchema });
5420	await finishProviderRequest(!data?.error);
5421	return data;
5422	}	5391	}
5423	}	5392	}
5424		5393

      * @param {Error|object} exception Error or response JSON
      * @throws {Error|object} Re-throws the exception
      */
-    async function onError(exception) {
+    function onError(exception) {
         // if the response JSON was thrown (novel|textgenerationwebui|kobold), show the error message
         if (typeof exception?.error?.message === 'string') {
             toastr.error(exception.error.message, t`Text generation error`, { timeOut: 10000, extendedTimeOut: 20000 });
+        }
-        await finishProviderRequest(false);
         unblockGeneration(type);
         console.log(exception);
         streamingProcessor = null;

public/scripts/events.js+0 -4 Viewed

     GENERATION_STARTED: 'generation_started',
     GENERATION_STOPPED: 'generation_stopped',
     GENERATION_ENDED: 'generation_ended',
-    GENERATION_REQUEST_STARTED: 'generation_request_started',
-    GENERATION_REQUEST_FINISHED: 'generation_request_finished',
     SD_PROMPT_PROCESSING: 'sd_prompt_processing',
     EXTENSIONS_FIRST_LOAD: 'extensions_first_load',
     EXTENSION_SETTINGS_LOADED: 'extension_settings_loaded',

     ONLINE_STATUS_CHANGED: 'online_status_changed',
     IMAGE_SWIPED: 'image_swiped',
     CONNECTION_PROFILE_LOADED: 'connection_profile_loaded',
-    CONNECTION_PROFILE_TEMPORARY_STARTED: 'connection_profile_temporary_started',
-    CONNECTION_PROFILE_TEMPORARY_ENDED: 'connection_profile_temporary_ended',
     CONNECTION_PROFILE_CREATED: 'connection_profile_created',
     CONNECTION_PROFILE_DELETED: 'connection_profile_deleted',
     CONNECTION_PROFILE_UPDATED: 'connection_profile_updated',

public/scripts/extensions/keepalive/index.js+0 -664 Viewed

-import { extension_settings, renderExtensionTemplateAsync } from '../../extensions.js';
-import {
-    Generate,
-    eventSource,
-    event_types,
-    extension_prompt_roles,
-    extension_prompt_types,
-    getGenerateUrl,
-    getRequestHeaders,
-    isGenerating,
-    main_api,
-    saveSettingsDebounced,
-    setExtensionPrompt,
-} from '../../../script.js';
-import { createGenerationParameters, getChatCompletionModel, oai_settings } from '../../openai.js';
-import { horde_settings } from '../../horde.js';
-import { uuidv4 } from '../../utils.js';
-export { init };
-const MODULE = 'keepalive';
-// Cap the keepalive completion to a single token. The full prompt prefix is
-// still processed by the backend (which is what refreshes the server-side
-// cache), but we never pay for a full completion.
-const KEEPALIVE_RESPONSE_LENGTH = 1;
-const HEARTBEAT_INTERVAL_MS = 20000;
-const RETRY_INTERVAL_MS = 5000;
-const SETTINGS_REFRESH_DELAY_MS = 300;
-const MAIN_CHAT_GENERATION_TYPES = new Set(['normal', 'regenerate', 'swipe', 'continue']);
-// Extension-prompt key used to inject the keepalive message as a USER message at depth 0.
-const KEEPALIVE_INJECT_ID = 'keepalive_ping';
-// Original default message; used to migrate untouched installs to the current default wording.
-const LEGACY_DEFAULT_MESSAGE = 'Keep the cache warm.';
-// Idle-tracking key used when no connection profile is active (manual API panel).
-const NONE_KEY = '__none__';
-const defaultSettings = {
-    enabled: false,
-    timeoutSeconds: 295,
-    message: '[Note: just reply with an empty response to keep the session alive]',
-    // Per-profile enable map: { [profileId]: boolean }. Unlisted profiles default to enabled.
-    profiles: {},
-};
-let heartbeatTimer = null;
-let jobRegistered = false;
-let refreshPromise = null;
-let refreshRequested = false;
-let refreshTimer = null;
-let generationRefreshTimer = null;
-let retryTimer = null;
-let preparingJob = false;
-let lifecycleVersion = 0;
-let temporaryConnectionDepth = 0;
-let refreshAfterTemporaryConnection = false;
-const activeMainRequests = new Map();
-let latestSuccessfulRequestStartedAt = 0;
-// Whether keepalive is "armed" for the CURRENT chat. It stays dormant until the user sends a new
-// message or starts another foreground generation in the open chat. Merely loading a chat does not
-// prove that its prompt is cached server-side. Reset on page reload and whenever the chat changes.
-let armed = false;
-// Per-profile time of the last verified successful main-chat inference request, keyed by
-// connection profile id (or NONE_KEY). In-memory only; a reload starts disarmed.
-const lastActivity = {};
-// Last successful backend keepalive, keyed by connection profile. The backend returns this after a
-// sleeping tab wakes so we can distinguish a still-warm prompt from an expired one.
-const lastKeepalive = {};
-// Per-document ids keep duplicated tabs independent. Jobs orphaned by a closed or reloaded
-// document are deliberately cleaned up by the backend lease.
-const keepaliveJobId = uuidv4().replaceAll('-', '');
-/**
- * @returns {string} The active connection profile id, or NONE_KEY for a manual connection.
- */
-function getActiveProfileKey() {
-    return extension_settings.connectionManager?.selectedProfile || NONE_KEY;
-}
-/**
- * Whether keepalive should run for the CURRENTLY ACTIVE connection. Requires the global
- * master switch; for a real profile it also requires that profile's per-profile toggle
- * (default on). A manual connection (no profile selected) is governed by the master switch alone.
- * @returns {boolean}
- */
-function isKeepaliveEnabledForActive() {
-    const s = extension_settings[MODULE];
-    if (!s.enabled) {
-        return false;
-    }
-    const profileId = extension_settings.connectionManager?.selectedProfile;
-    if (!profileId) {
-        return true;
-    }
-    const perProfile = s.profiles?.[profileId];
-    return perProfile === undefined ? true : !!perProfile;
-}
-function getTimeoutMs() {
-    return Math.max(60, Number(extension_settings[MODULE].timeoutSeconds) || 295) * 1000;
-}
-function updateLastKeepalive(profileKey, value) {
-    const timestamp = Number(value);
-    if (Number.isFinite(timestamp) && timestamp > 0) {
-        lastKeepalive[profileKey] = Math.max(lastKeepalive[profileKey] || 0, timestamp);
-    }
-}
-function getLastWarmTime(profileKey = getActiveProfileKey()) {
-    return Math.max(lastActivity[profileKey] || 0, lastKeepalive[profileKey] || 0);
-}
-function isWarmPromptExpired(profileKey = getActiveProfileKey()) {
-    const lastWarmTime = getLastWarmTime(profileKey);
-    return lastWarmTime > 0 && (Date.now() - lastWarmTime) >= getTimeoutMs();
-}
-function disarmExpiredJob() {
-    armed = false;
-    jobRegistered = false;
-    refreshRequested = false;
-    lifecycleVersion++;
-    clearTimeout(retryTimer);
-    clearTimeout(refreshTimer);
-    clearTimeout(generationRefreshTimer);
-}
-async function postKeepaliveBackend(path, body) {
-    return fetch(`/api/keepalive/${path}`, {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        body: JSON.stringify({ id: keepaliveJobId, ...body }),
-    });
-}
-async function stopBackendJob() {
-    lifecycleVersion++;
-    jobRegistered = false;
-    clearTimeout(retryTimer);
-    try {
-        await postKeepaliveBackend('stop', {});
-    } catch (error) {
-        console.debug('[Keepalive] Could not stop backend job:', error);
-    }
-}
-async function sendBackendHeartbeat() {
-    if (temporaryConnectionDepth > 0 || !armed || !isKeepaliveEnabledForActive()) {
-        return;
-    }
-    // Registration is normally created as soon as a response finishes. If that one-shot event
-    // was missed (or registration failed), the regular heartbeat must self-heal instead of doing
-    // nothing forever.
-    if (!jobRegistered) {
-        if (isWarmPromptExpired()) {
-            disarmExpiredJob();
-            return;
-        }
-        queueJobRefresh();
-        return;
-    }
-    const version = lifecycleVersion;
-    const profileKey = getActiveProfileKey();
-    try {
-        const response = await postKeepaliveBackend('heartbeat', {});
-        const state = await response.json().catch(() => ({}));
-        if (version !== lifecycleVersion) {
-            return;
-        }
-        updateLastKeepalive(profileKey, state.lastRun);
-        if (response.status === 404) {
-            jobRegistered = false;
-            if (isWarmPromptExpired(profileKey)) {
-                disarmExpiredJob();
-                return;
-            }
-            queueJobRefresh();
-        }
-    } catch (error) {
-        console.debug('[Keepalive] Backend heartbeat failed:', error);
-    }
-}
-/**
- * A new user message may lead to a main-chat request, but does not prove the provider accepted it.
- * Arm the feature and refresh only the replay payload; the deadline remains unchanged until the
- * request-success event arrives.
- */
-function onMessageSent() {
-    armed = true;
-    queueJobRefresh();
-}
-/**
- * Opening or switching chats disarms keepalive: a freshly loaded chat is not proof its prompt is
- * still cached server-side, so we wait for a new message or foreground generation before running.
- */
-function onChatChanged() {
-    armed = false;
-    activeMainRequests.clear();
-    latestSuccessfulRequestStartedAt = 0;
-    void stopBackendJob();
-}
-/**
- * Caps a prepared request to a single, non-streaming completion token.
- * @param {string} endpoint Backend generation endpoint.
- * @param {object} payload Prepared generation payload.
- * @returns {object} Cloned and capped payload.
- */
-function capKeepalivePayload(endpoint, payload) {
-    const capped = structuredClone(payload);
-    capped.stream = false;
-    for (const key of ['max_tokens', 'max_completion_tokens', 'max_length', 'max_new_tokens', 'n_predict']) {
-        if (Object.hasOwn(capped, key)) {
-            capped[key] = KEEPALIVE_RESPONSE_LENGTH;
-        }
-    }
-    if (endpoint === '/api/backends/chat-completions/generate'
-        && !Object.hasOwn(capped, 'max_tokens')
-        && !Object.hasOwn(capped, 'max_completion_tokens')) {
-        capped.max_tokens = KEEPALIVE_RESPONSE_LENGTH;
-    }
-    if (Object.hasOwn(capped, 'n')) {
-        capped.n = 1;
-    }
-    return capped;
-}
-/**
- * Dry-runs prompt assembly and returns a request the backend can replay later.
- * @returns {Promise<{endpoint: string, payload: object}>}
- */
-async function prepareKeepaliveRequest() {
-    const api = main_api;
-    let capturedData = null;
-    const captureData = (data, dryRun) => {
-        if (dryRun && preparingJob) {
-            capturedData = structuredClone(data);
-        }
-    };
-    preparingJob = true;
-    eventSource.on(event_types.GENERATE_AFTER_DATA, captureData);
-    setExtensionPrompt(KEEPALIVE_INJECT_ID, extension_settings[MODULE].message, extension_prompt_types.IN_CHAT, 0, false, extension_prompt_roles.USER);
-    try {
-        // A normal live request applies the user's system-message squashing after prompt assembly.
-        // Opt into the same final transform here so provider cache keys see identical boundaries.
-        await Generate('quiet', { quiet_prompt: '', force_name2: true, squashSystemMessages: true }, true);
-    } finally {
-        setExtensionPrompt(KEEPALIVE_INJECT_ID, '', extension_prompt_types.IN_CHAT, 0, false, extension_prompt_roles.USER);
-        eventSource.removeListener(event_types.GENERATE_AFTER_DATA, captureData);
-        preparingJob = false;
-    }
-    if (!capturedData || api !== main_api) {
-        throw new Error('Active connection changed while preparing the keepalive request');
-    }
-    let endpoint;
-    let payload;
-    if (api === 'openai') {
-        endpoint = '/api/backends/chat-completions/generate';
-        const model = getChatCompletionModel(oai_settings);
-        ({ generate_data: payload } = await createGenerationParameters(oai_settings, model, 'quiet', capturedData.prompt));
-        await eventSource.emit(event_types.CHAT_COMPLETION_SETTINGS_READY, payload);
-    } else if (api === 'koboldhorde') {
-        endpoint = '/api/horde/generate-text';
-        const params = structuredClone(capturedData);
-        const prompt = params.prompt;
-        delete params.prompt;
-        Object.assign(params, {
-            n: 1,
-            max_length: KEEPALIVE_RESPONSE_LENGTH,
-            frmtadsnsp: false,
-            frmtrmblln: false,
-            frmtrmspch: false,
-            frmttriminc: false,
-        });
-        payload = {
-            prompt,
-            params,
-            trusted_workers: horde_settings.trusted_workers_only,
-            models: horde_settings.models,
-        };
-    } else {
-        endpoint = getGenerateUrl(api);
-        payload = capturedData;
-    }
-    return { endpoint, payload: capKeepalivePayload(endpoint, payload) };
-}
-async function registerBackendJob() {
-    if (temporaryConnectionDepth > 0) {
-        refreshAfterTemporaryConnection = true;
-        return;
-    }
-    if (!armed || !isKeepaliveEnabledForActive()) {
-        await stopBackendJob();
-        return;
-    }
-    const profileKey = getActiveProfileKey();
-    if (!getLastWarmTime(profileKey)) {
-        return;
-    }
-    if (isWarmPromptExpired(profileKey)) {
-        disarmExpiredJob();
-        return;
-    }
-    const version = lifecycleVersion;
-    const hadRegisteredJob = jobRegistered;
-    try {
-        if (isGenerating()) {
-            throw new Error('Waiting for the active generation to finish');
-        }
-        const request = await prepareKeepaliveRequest();
-        if (version !== lifecycleVersion || !armed || !isKeepaliveEnabledForActive()) {
-            return;
-        }
-        const timeoutMs = getTimeoutMs();
-        const last = getLastWarmTime(profileKey) || Date.now();
-        const remaining = timeoutMs - (Date.now() - last);
-        if (remaining <= 0) {
-            disarmExpiredJob();
-            return;
-        }
-        const response = await postKeepaliveBackend('register', {
-            ...request,
-            intervalMs: timeoutMs,
-            delayMs: remaining,
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-        }
-        if (version !== lifecycleVersion || !armed || !isKeepaliveEnabledForActive()) {
-            await stopBackendJob();
-            return;
-        }
-        clearTimeout(retryTimer);
-        jobRegistered = true;
-    } catch (error) {
-        // A failed payload refresh does not mean the existing backend job disappeared. Keeping
-        // this state is especially important while a foreground request is starting, because its
-        // lifecycle handler still needs to pause that existing job before provider dispatch.
-        jobRegistered = hadRegisteredJob;
-        console.debug('[Keepalive] Could not register backend job:', error);
-        clearTimeout(retryTimer);
-        retryTimer = setTimeout(queueJobRefresh, RETRY_INTERVAL_MS);
-    }
-}
-function queueJobRefresh() {
-    refreshRequested = true;
-    if (refreshPromise) {
-        return;
-    }
-    refreshPromise = (async () => {
-        while (refreshRequested) {
-            refreshRequested = false;
-            await registerBackendJob();
-        }
-    })().finally(() => {
-        refreshPromise = null;
-    });
-}
-function scheduleJobRefresh() {
-    clearTimeout(refreshTimer);
-    refreshTimer = setTimeout(queueJobRefresh, SETTINGS_REFRESH_DELAY_MS);
-}
-function scheduleGenerationJobRefresh() {
-    clearTimeout(generationRefreshTimer);
-    generationRefreshTimer = setTimeout(() => {
-        if (armed && isKeepaliveEnabledForActive()) {
-            queueJobRefresh();
-        }
-    }, SETTINGS_REFRESH_DELAY_MS);
-}
-function setupHeartbeatLoop() {
-    clearInterval(heartbeatTimer);
-    heartbeatTimer = setInterval(() => void sendBackendHeartbeat(), HEARTBEAT_INTERVAL_MS);
-    document.addEventListener('visibilitychange', () => {
-        if (document.visibilityState === 'visible') {
-            void sendBackendHeartbeat();
-        }
-    });
-}
-/**
- * Renders the per-profile enable checkboxes from the current Connection Manager profiles.
- */
-function renderProfileToggles() {
-    const container = $('#keepalive_profiles_list');
-    if (!container.length) {
-        return;
-    }
-    container.empty();
-    const profiles = extension_settings.connectionManager?.profiles;
-    if (!Array.isArray(profiles) || profiles.length === 0) {
-        container.append(
-            $('<small>')
-                .attr('data-i18n', 'ext_keepalive_no_profiles')
-                .text('No connection profiles found. Keepalive uses the active model, governed by the master toggle above.'),
-        );
-        return;
-    }
-    const perProfile = extension_settings[MODULE].profiles || {};
-    const sorted = profiles.slice().sort((a, b) => String(a.name).localeCompare(String(b.name)));
-    for (const profile of sorted) {
-        const enabled = perProfile[profile.id] === undefined ? true : !!perProfile[profile.id];
-        const label = $('<label>').addClass('checkbox_label');
-        const input = $('<input>')
-            .attr('type', 'checkbox')
-            .addClass('keepalive_profile_toggle')
-            .attr('data-profile-id', profile.id)
-            .prop('checked', enabled);
-        const span = $('<span>').text(profile.name);
-        label.append(input, span);
-        container.append(label);
-    }
-}
-/**
- * Loads settings into the global store and hydrates the UI controls.
- */
-function loadSettings() {
-    if (extension_settings[MODULE] === undefined) {
-        extension_settings[MODULE] = {};
-    }
-    for (const key of Object.keys(defaultSettings)) {
-        if (extension_settings[MODULE][key] === undefined) {
-            extension_settings[MODULE][key] = structuredClone(defaultSettings[key]);
-        }
-    }
-    // Guard against a corrupted/legacy value for the per-profile map.
-    if (typeof extension_settings[MODULE].profiles !== 'object' || extension_settings[MODULE].profiles === null) {
-        extension_settings[MODULE].profiles = {};
-    }
-    // Migrate the original default message to the current default so installs that never
-    // customized it pick up the improved wording (custom messages are left untouched).
-    if (extension_settings[MODULE].message === LEGACY_DEFAULT_MESSAGE) {
-        extension_settings[MODULE].message = defaultSettings.message;
-        saveSettingsDebounced();
-    }
-    $('#keepalive_enabled').prop('checked', extension_settings[MODULE].enabled);
-    $('#keepalive_timeout').val(extension_settings[MODULE].timeoutSeconds);
-    $('#keepalive_message').val(extension_settings[MODULE].message);
-    renderProfileToggles();
-}
-/**
- * Wires up the settings UI control handlers.
- */
-function setupListeners() {
-    $('#keepalive_enabled').on('change', function () {
-        extension_settings[MODULE].enabled = !!$(this).prop('checked');
-        saveSettingsDebounced();
-        if (extension_settings[MODULE].enabled && armed) {
-            queueJobRefresh();
-        } else {
-            void stopBackendJob();
-        }
-    });
-    $('#keepalive_timeout').on('input', function () {
-        extension_settings[MODULE].timeoutSeconds = Number($(this).val()) || 295;
-        saveSettingsDebounced();
-        if (armed && isKeepaliveEnabledForActive()) {
-            scheduleJobRefresh();
-        }
-    });
-    $('#keepalive_message').on('input', function () {
-        extension_settings[MODULE].message = String($(this).val());
-        saveSettingsDebounced();
-        if (armed && isKeepaliveEnabledForActive()) {
-            scheduleJobRefresh();
-        }
-    });
-    // Per-profile toggles are rendered dynamically; use a delegated handler.
-    $('#keepalive_profiles_list').on('change', '.keepalive_profile_toggle', function () {
-        const profileId = $(this).attr('data-profile-id');
-        if (!profileId) {
-            return;
-        }
-        extension_settings[MODULE].profiles[profileId] = !!$(this).prop('checked');
-        saveSettingsDebounced();
-        // If the toggled profile is the one currently active, update its backend job immediately.
-        if (profileId === extension_settings.connectionManager?.selectedProfile) {
-            if (isKeepaliveEnabledForActive() && armed) {
-                queueJobRefresh();
-            } else {
-                void stopBackendJob();
-            }
-        }
-    });
-}
-async function pauseBackendJob() {
-    if (!jobRegistered) {
-        return;
-    }
-    try {
-        const response = await postKeepaliveBackend('pause', {});
-        if (response.status === 404) {
-            jobRegistered = false;
-        }
-    } catch (error) {
-        console.debug('[Keepalive] Could not pause backend job:', error);
-    }
-}
-async function resumeBackendJob(activityStartedAt = null) {
-    if (!jobRegistered) {
-        return;
-    }
-    const elapsedMs = Number.isFinite(activityStartedAt)
-        ? Math.max(0, Date.now() - activityStartedAt)
-        : null;
-    const profileKey = getActiveProfileKey();
-    try {
-        const response = await postKeepaliveBackend('resume', {
-            activityElapsedMs: elapsedMs,
-        });
-        const state = await response.json().catch(() => ({}));
-        updateLastKeepalive(profileKey, state.lastRun);
-        if (response.status === 404) {
-            jobRegistered = false;
-        }
-    } catch (error) {
-        console.debug('[Keepalive] Could not resume backend job:', error);
-    }
-}
-async function onGenerationRequestStarted(request) {
-    if (temporaryConnectionDepth > 0 || !request?.id || !MAIN_CHAT_GENERATION_TYPES.has(request.type)) {
-        return;
-    }
-    armed = true;
-    activeMainRequests.set(request.id, {
-        profileKey: getActiveProfileKey(),
-        startedAt: Number(request.startedAt) || Date.now(),
-    });
-    if (activeMainRequests.size === 1) {
-        await pauseBackendJob();
-    }
-}
-async function onGenerationRequestFinished(request) {
-    const activeRequest = activeMainRequests.get(request?.id);
-    if (!activeRequest) {
-        return;
-    }
-    activeMainRequests.delete(request.id);
-    if (request.success) {
-        const startedAt = activeRequest.startedAt;
-        lastActivity[activeRequest.profileKey] = Math.max(lastActivity[activeRequest.profileKey] || 0, startedAt);
-        latestSuccessfulRequestStartedAt = Math.max(latestSuccessfulRequestStartedAt, startedAt);
-        armed = true;
-    }
-    if (activeMainRequests.size > 0) {
-        return;
-    }
-    const successfulStartedAt = latestSuccessfulRequestStartedAt || null;
-    latestSuccessfulRequestStartedAt = 0;
-    await resumeBackendJob(successfulStartedAt);
-    // A failed request may still have changed local chat content, so refresh the replay payload,
-    // but registerBackendJob() will retain the old deadline. A successful request supplies the
-    // verified activity timestamp used for the new deadline.
-    scheduleGenerationJobRefresh();
-}
-function onChatContentChanged() {
-    // Editing, deleting, or swiping local chat content does not contact the text provider and
-    // therefore cannot refresh its prompt cache. Rebuild the replay payload, but preserve the
-    // deadline from the last real text generation/keepalive. This also keeps image-message edits
-    // and gallery activity from postponing text keepalives.
-    if (armed && isKeepaliveEnabledForActive()) {
-        queueJobRefresh();
-    }
-}
-async function onConnectionChanged() {
-    if (temporaryConnectionDepth > 0) {
-        return;
-    }
-    // Remove the previous connection's request before assembling one with the new settings.
-    await stopBackendJob();
-    if (armed && isKeepaliveEnabledForActive()) {
-        queueJobRefresh();
-    }
-}
-function onTemporaryConnectionStarted() {
-    temporaryConnectionDepth++;
-}
-function onTemporaryConnectionEnded() {
-    temporaryConnectionDepth = Math.max(0, temporaryConnectionDepth - 1);
-    if (temporaryConnectionDepth === 0 && refreshAfterTemporaryConnection) {
-        refreshAfterTemporaryConnection = false;
-        queueJobRefresh();
-    }
-}
-async function init() {
-    const settingsHtml = await renderExtensionTemplateAsync(MODULE, 'settings');
-    $('#extensions_settings2').append(settingsHtml);
-    loadSettings();
-    setupListeners();
-    setupHeartbeatLoop();
-    // A user message arms keepalive, but only the exact provider-request lifecycle below is allowed
-    // to move its deadline. Regenerate/swipe/continue requests arm it when their request starts.
-    eventSource.on(event_types.MESSAGE_SENT, onMessageSent);
-    // Only actual text-provider generations reset the cache deadline. Local chat edits still
-    // refresh the stored request so the server replays the latest prompt without pretending that
-    // those edits refreshed the provider cache.
-    eventSource.on(event_types.GENERATION_REQUEST_STARTED, onGenerationRequestStarted);
-    eventSource.on(event_types.GENERATION_REQUEST_FINISHED, onGenerationRequestFinished);
-    eventSource.on(event_types.MESSAGE_EDITED, onChatContentChanged);
-    eventSource.on(event_types.MESSAGE_DELETED, onChatContentChanged);
-    eventSource.on(event_types.MESSAGE_UPDATED, onChatContentChanged);
-    eventSource.on(event_types.MESSAGE_SWIPED, onChatContentChanged);
-    // Opening/switching a chat disarms keepalive — it must be re-armed by a new sent message.
-    eventSource.on(event_types.CHAT_CHANGED, onChatChanged);
-    // When the active profile changes, replace the backend job without marking it as activity.
-    // Temporary profile switches used by background image-prompt generation are explicitly ignored.
-    eventSource.on(event_types.CONNECTION_PROFILE_TEMPORARY_STARTED, onTemporaryConnectionStarted);
-    eventSource.on(event_types.CONNECTION_PROFILE_TEMPORARY_ENDED, onTemporaryConnectionEnded);
-    eventSource.on(event_types.CONNECTION_PROFILE_LOADED, onConnectionChanged);
-    eventSource.on(event_types.MAIN_API_CHANGED, onConnectionChanged);
-    eventSource.on(event_types.CHATCOMPLETION_SOURCE_CHANGED, onConnectionChanged);
-    eventSource.on(event_types.CHATCOMPLETION_MODEL_CHANGED, onConnectionChanged);
-    eventSource.on(event_types.PRESET_CHANGED, onConnectionChanged);
-    // Keep the per-profile toggle list in sync with Connection Manager.
-    eventSource.on(event_types.CONNECTION_PROFILE_CREATED, renderProfileToggles);
-    eventSource.on(event_types.CONNECTION_PROFILE_UPDATED, renderProfileToggles);
-    eventSource.on(event_types.CONNECTION_PROFILE_DELETED, renderProfileToggles);
-}

public/scripts/extensions/keepalive/manifest.json+0 -14 Viewed

-{
-    "display_name": "Cache Keepalive",
-    "loading_order": 100,
-    "requires": [],
-    "optional": [],
-    "js": "index.js",
-    "css": "",
-    "author": "SillyTavern",
-    "version": "1.1.6",
-    "homePage": "https://github.com/SillyTavern/SillyTavern",
-    "hooks": {
-        "activate": "init"
-    }
-}

public/scripts/extensions/keepalive/settings.html+0 -28 Viewed

-<div id="keepalive_settings">
-    <div class="inline-drawer">
-        <div class="inline-drawer-toggle inline-drawer-header">
-            <b data-i18n="ext_keepalive_title">Cache Keepalive</b>
-            <div class="inline-drawer-icon fa-solid fa-circle-chevron-down down"></div>
-        </div>
-        <div class="inline-drawer-content">
-            <label class="checkbox_label" for="keepalive_enabled">
-                <input id="keepalive_enabled" type="checkbox" />
-                <span data-i18n="ext_keepalive_enable">Enable cache keepalive (master switch)</span>
-            </label>
-            <label for="keepalive_timeout" data-i18n="ext_keepalive_timeout">Idle timeout (seconds)</label>
-            <input id="keepalive_timeout" class="text_pole" type="number" min="60" step="1" />
-            <label for="keepalive_message" data-i18n="ext_keepalive_message">Keepalive message</label>
-            <input id="keepalive_message" class="text_pole" type="text" />
-            <small data-i18n="ext_keepalive_help">After this many seconds without activity on the active connection profile, the current chat plus this message (sent as a hidden user message) is submitted to that profile to keep its server-side prompt cache warm. The completion is capped to a single token and is never saved to the chat. The server owns the keepalive timer, while this tab renews its lease every 20 seconds; if the tab sleeps or closes, the server continues on schedule for up to five minutes after the last heartbeat. Waking a tab after both its lease and cache window have expired does not restart keepalives until a new message, regenerate, swipe, or continue. Only the profile you're currently using is pinged. Merely opening, switching to, or reloading a chat is not proof its prompt is cached.</small>
-            <hr>
-            <label data-i18n="ext_keepalive_profiles_label">Keepalive per connection profile</label>
-            <small data-i18n="ext_keepalive_profiles_desc">Turn keepalive on only for the profiles whose providers support prompt caching (leave the others off so you don't waste requests). The master switch above must be enabled. Profiles default to on.</small>
-            <div id="keepalive_profiles_list" class="keepalive_profiles_list"></div>
-        </div>
-    </div>
-</div>

public/scripts/extensions/memory/index.js+0 -1299 Viewed

-import { getStringHash, debounce, waitUntilCondition, extractAllWords, isTrueBoolean } from '../../utils.js';
-import { getContext, getApiUrl, extension_settings, doExtrasFetch, modules, renderExtensionTemplateAsync } from '../../extensions.js';
-import {
-    activateSendButtons,
-    deactivateSendButtons,
-    animation_duration,
-    eventSource,
-    event_types,
-    extension_prompt_roles,
-    extension_prompt_types,
-    generateQuietPrompt,
-    is_send_press,
-    online_status,
-    saveSettingsDebounced,
-    substituteParamsExtended,
-    generateRaw,
-    getMaxPromptTokens,
-    setExtensionPrompt,
-    streamingProcessor,
-    animation_easing,
-} from '../../../script.js';
-import { is_group_generating, selected_group } from '../../group-chats.js';
-import { loadMovingUIState, power_user } from '../../power-user.js';
-import { dragElement } from '../../RossAscends-mods.js';
-import { getTextTokens, getTokenCountAsync, tokenizers } from '../../tokenizers.js';
-import { debounce_timeout } from '../../constants.js';
-import { SlashCommandParser } from '../../slash-commands/SlashCommandParser.js';
-import { SlashCommand } from '../../slash-commands/SlashCommand.js';
-import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from '../../slash-commands/SlashCommandArgument.js';
-import { macros, MacroCategory } from '../../macros/macro-system.js';
-import { ConnectionManagerRequestService, countWebLlmTokens, generateWebLlmChatPrompt, getWebLlmContextSize, isWebLlmSupported } from '../shared.js';
-import { commonEnumProviders } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
-import { removeReasoningFromString } from '../../reasoning.js';
-import { MacrosParser } from '/scripts/macros.js';
-export { MODULE_NAME };
-const MODULE_NAME = '1_memory';
-let lastMessageHash = null;
-let lastMessageId = null;
-let inApiCall = false;
-/**
- * Count the number of tokens in the provided text.
- * @param {string} text Text to count tokens for
- * @param {number} padding Number of additional tokens to add to the count
- * @returns {Promise<number>} Number of tokens in the text
- */
-async function countSourceTokens(text, padding = 0) {
-    if (extension_settings.memory.source === summary_sources.webllm) {
-        const count = await countWebLlmTokens(text);
-        return count + padding;
-    }
-    if (extension_settings.memory.source === summary_sources.extras) {
-        const count = getTextTokens(tokenizers.GPT2, text).length;
-        return count + padding;
-    }
-    return await getTokenCountAsync(text, padding);
-}
-async function getSourceContextSize() {
-    const overrideLength = extension_settings.memory.overrideResponseLength;
-    if (extension_settings.memory.source === summary_sources.webllm) {
-        const maxContext = await getWebLlmContextSize();
-        return overrideLength > 0 ? (maxContext - overrideLength) : Math.round(maxContext * 0.75);
-    }
-    if (extension_settings.source === summary_sources.extras) {
-        return 1024 - 64;
-    }
-    return getMaxPromptTokens(overrideLength);
-}
-const formatMemoryValue = function (value) {
-    if (!value) {
-        return '';
-    }
-    value = value.trim();
-    if (extension_settings.memory.template) {
-        return substituteParamsExtended(extension_settings.memory.template, { summary: value });
-    } else {
-        return `Summary: ${value}`;
-    }
-};
-const saveChatDebounced = debounce(() => getContext().saveChat(), debounce_timeout.relaxed);
-const summary_sources = {
-    'extras': 'extras',
-    'main': 'main',
-    'webllm': 'webllm',
-};
-const prompt_builders = {
-    DEFAULT: 0,
-    RAW_BLOCKING: 1,
-    RAW_NON_BLOCKING: 2,
-};
-const defaultPrompt = 'Ignore previous instructions. Summarize the most important facts and events in the story so far. If a summary already exists in your memory, use that as a base and expand with new facts. Limit the summary to {{words}} words or less. Your response should include nothing but the summary.';
-const defaultTemplate = '[Summary: {{summary}}]';
-const defaultSettings = {
-    memoryFrozen: false,
-    SkipWIAN: false,
-    source: summary_sources.extras,
-    prompt: defaultPrompt,
-    template: defaultTemplate,
-    position: extension_prompt_types.IN_PROMPT,
-    role: extension_prompt_roles.SYSTEM,
-    scan: false,
-    depth: 2,
-    promptWords: 200,
-    promptMinWords: 25,
-    promptMaxWords: 1000,
-    promptWordsStep: 25,
-    promptInterval: 10,
-    promptMinInterval: 0,
-    promptMaxInterval: 250,
-    promptIntervalStep: 1,
-    promptForceWords: 0,
-    promptForceWordsStep: 100,
-    promptMinForceWords: 0,
-    promptMaxForceWords: 10000,
-    overrideResponseLength: 0,
-    overrideResponseLengthMin: 0,
-    overrideResponseLengthMax: 4096,
-    overrideResponseLengthStep: 16,
-    maxMessagesPerRequest: 0,
-    maxMessagesPerRequestMin: 0,
-    maxMessagesPerRequestMax: 250,
-    maxMessagesPerRequestStep: 1,
-    prompt_builder: prompt_builders.DEFAULT,
-    summaryPromptRole: extension_prompt_roles.SYSTEM,
-    summaryConnectionProfile: '',
-};
-/**
- * Resolve the configured role for the summarization request prompt.
- * Only SYSTEM and USER are supported; anything else falls back to SYSTEM.
- * @returns {number} One of extension_prompt_roles.SYSTEM or extension_prompt_roles.USER
- */
-function getSummaryPromptRole() {
-    return Number(extension_settings.memory.summaryPromptRole) === extension_prompt_roles.USER
-        ? extension_prompt_roles.USER
-        : extension_prompt_roles.SYSTEM;
-}
-let summaryConnectionProfileDropdownInitialized = false;
-/**
- * Populates the dedicated summarization connection profile dropdown.
- * Only initializes once to avoid attaching duplicate Connection Manager event listeners
- * when loadSettings() is called again (e.g. after loading a settings preset).
- */
-function initSummaryConnectionProfileDropdown() {
-    if (summaryConnectionProfileDropdownInitialized) {
-        return;
-    }
-    try {
-        ConnectionManagerRequestService.handleDropdown(
-            '#memory_summary_connection_profile',
-            extension_settings.memory.summaryConnectionProfile,
-            (profile) => {
-                extension_settings.memory.summaryConnectionProfile = profile?.id ?? '';
-                saveSettingsDebounced();
-            },
-        );
-        summaryConnectionProfileDropdownInitialized = true;
-    } catch (error) {
-        // Connection Manager may be unavailable/disabled; leave the dropdown empty in that case.
-        console.warn('Summarize: could not populate summary connection profile dropdown', error);
-    }
-}
-function loadSettings() {
-    if (Object.keys(extension_settings.memory).length === 0) {
-        Object.assign(extension_settings.memory, defaultSettings);
-    }
-    for (const key of Object.keys(defaultSettings)) {
-        if (extension_settings.memory[key] === undefined) {
-            extension_settings.memory[key] = defaultSettings[key];
-        }
-    }
-    $('#summary_source').val(extension_settings.memory.source).trigger('change');
-    $('#memory_frozen').prop('checked', extension_settings.memory.memoryFrozen).trigger('input');
-    $('#memory_skipWIAN').prop('checked', extension_settings.memory.SkipWIAN).trigger('input');
-    $('#memory_prompt').val(extension_settings.memory.prompt).trigger('input');
-    $('#memory_prompt_words').val(extension_settings.memory.promptWords).trigger('input');
-    $('#memory_prompt_interval').val(extension_settings.memory.promptInterval).trigger('input');
-    $('#memory_template').val(extension_settings.memory.template).trigger('input');
-    $('#memory_depth').val(extension_settings.memory.depth).trigger('input');
-    $('#memory_role').val(extension_settings.memory.role).trigger('input');
-    $('#memory_summary_prompt_role').val(extension_settings.memory.summaryPromptRole).trigger('input');
-    initSummaryConnectionProfileDropdown();
-    $(`input[name="memory_position"][value="${extension_settings.memory.position}"]`).prop('checked', true).trigger('input');
-    $('#memory_prompt_words_force').val(extension_settings.memory.promptForceWords).trigger('input');
-    $(`input[name="memory_prompt_builder"][value="${extension_settings.memory.prompt_builder}"]`).prop('checked', true).trigger('input');
-    $('#memory_override_response_length').val(extension_settings.memory.overrideResponseLength).trigger('input');
-    $('#memory_max_messages_per_request').val(extension_settings.memory.maxMessagesPerRequest).trigger('input');
-    $('#memory_include_wi_scan').prop('checked', extension_settings.memory.scan).trigger('input');
-    switchSourceControls(extension_settings.memory.source);
-}
-async function onPromptForceWordsAutoClick() {
-    const context = getContext();
-    const maxPromptLength = await getSourceContextSize();
-    const chat = context.chat;
-    const allMessages = chat.filter(m => !m.is_system && m.mes).map(m => m.mes);
-    const messagesWordCount = allMessages.map(m => extractAllWords(m)).flat().length;
-    const averageMessageWordCount = messagesWordCount / allMessages.length;
-    const tokensPerWord = await countSourceTokens(allMessages.join('\n')) / messagesWordCount;
-    const wordsPerToken = 1 / tokensPerWord;
-    const maxPromptLengthWords = Math.round(maxPromptLength * wordsPerToken);
-    // How many words should pass so that messages will start be dropped out of context;
-    const wordsPerPrompt = Math.floor(maxPromptLength / tokensPerWord);
-    // How many words will be needed to fit the allowance buffer
-    const summaryPromptWords = extractAllWords(extension_settings.memory.prompt).length;
-    const promptAllowanceWords = maxPromptLengthWords - extension_settings.memory.promptWords - summaryPromptWords;
-    const averageMessagesPerPrompt = Math.floor(promptAllowanceWords / averageMessageWordCount);
-    const maxMessagesPerSummary = extension_settings.memory.maxMessagesPerRequest || 0;
-    const targetMessagesInPrompt = maxMessagesPerSummary > 0 ? maxMessagesPerSummary : Math.max(0, averageMessagesPerPrompt);
-    const targetSummaryWords = (targetMessagesInPrompt * averageMessageWordCount) + (promptAllowanceWords / 4);
-    console.table({
-        maxPromptLength,
-        maxPromptLengthWords,
-        promptAllowanceWords,
-        averageMessagesPerPrompt,
-        targetMessagesInPrompt,
-        targetSummaryWords,
-        wordsPerPrompt,
-        wordsPerToken,
-        tokensPerWord,
-        messagesWordCount,
-    });
-    const ROUNDING = 100;
-    extension_settings.memory.promptForceWords = Math.max(1, Math.floor(targetSummaryWords / ROUNDING) * ROUNDING);
-    $('#memory_prompt_words_force').val(extension_settings.memory.promptForceWords).trigger('input');
-}
-async function onPromptIntervalAutoClick() {
-    const context = getContext();
-    const maxPromptLength = await getSourceContextSize();
-    const chat = context.chat;
-    const allMessages = chat.filter(m => !m.is_system && m.mes).map(m => m.mes);
-    const messagesWordCount = allMessages.map(m => extractAllWords(m)).flat().length;
-    const messagesTokenCount = await countSourceTokens(allMessages.join('\n'));
-    const tokensPerWord = messagesTokenCount / messagesWordCount;
-    const averageMessageTokenCount = messagesTokenCount / allMessages.length;
-    const targetSummaryTokens = Math.round(extension_settings.memory.promptWords * tokensPerWord);
-    const promptTokens = await countSourceTokens(extension_settings.memory.prompt);
-    const promptAllowance = maxPromptLength - promptTokens - targetSummaryTokens;
-    const maxMessagesPerSummary = extension_settings.memory.maxMessagesPerRequest || 0;
-    const averageMessagesPerPrompt = Math.floor(promptAllowance / averageMessageTokenCount);
-    const targetMessagesInPrompt = maxMessagesPerSummary > 0 ? maxMessagesPerSummary : Math.max(0, averageMessagesPerPrompt);
-    const adjustedAverageMessagesPerPrompt = targetMessagesInPrompt + (averageMessagesPerPrompt - targetMessagesInPrompt) / 4;
-    console.table({
-        maxPromptLength,
-        promptAllowance,
-        targetSummaryTokens,
-        promptTokens,
-        messagesWordCount,
-        messagesTokenCount,
-        tokensPerWord,
-        averageMessageTokenCount,
-        averageMessagesPerPrompt,
-        targetMessagesInPrompt,
-        adjustedAverageMessagesPerPrompt,
-        maxMessagesPerSummary,
-    });
-    const ROUNDING = 5;
-    extension_settings.memory.promptInterval = Math.max(1, Math.floor(adjustedAverageMessagesPerPrompt / ROUNDING) * ROUNDING);
-    $('#memory_prompt_interval').val(extension_settings.memory.promptInterval).trigger('input');
-}
-function onSummarySourceChange(event) {
-    const value = event.target.value;
-    extension_settings.memory.source = value;
-    switchSourceControls(value);
-    saveSettingsDebounced();
-}
-function switchSourceControls(value) {
-    $('#summaryExtensionDrawerContents [data-summary-source], #memory_settings [data-summary-source]').each((_, element) => {
-        const source = element.dataset.summarySource.split(',').map(s => s.trim());
-        $(element).toggle(source.includes(value));
-    });
-}
-function onMemoryFrozenInput() {
-    const value = Boolean($(this).prop('checked'));
-    extension_settings.memory.memoryFrozen = value;
-    saveSettingsDebounced();
-}
-function onMemorySkipWIANInput() {
-    const value = Boolean($(this).prop('checked'));
-    extension_settings.memory.SkipWIAN = value;
-    saveSettingsDebounced();
-}
-function onMemoryPromptWordsInput() {
-    const value = $(this).val();
-    extension_settings.memory.promptWords = Number(value);
-    $('#memory_prompt_words_value').text(extension_settings.memory.promptWords);
-    saveSettingsDebounced();
-}
-function onMemoryPromptIntervalInput() {
-    const value = $(this).val();
-    extension_settings.memory.promptInterval = Number(value);
-    $('#memory_prompt_interval_value').text(extension_settings.memory.promptInterval);
-    saveSettingsDebounced();
-}
-function onMemoryPromptRestoreClick() {
-    $('#memory_prompt').val(defaultPrompt).trigger('input');
-}
-function onMemoryPromptInput() {
-    const value = $(this).val();
-    extension_settings.memory.prompt = value;
-    saveSettingsDebounced();
-}
-function onMemoryTemplateInput() {
-    const value = $(this).val();
-    extension_settings.memory.template = value;
-    reinsertMemory();
-    saveSettingsDebounced();
-}
-function onMemoryDepthInput() {
-    const value = $(this).val();
-    extension_settings.memory.depth = Number(value);
-    reinsertMemory();
-    saveSettingsDebounced();
-}
-function onMemoryRoleInput() {
-    const value = $(this).val();
-    extension_settings.memory.role = Number(value);
-    reinsertMemory();
-    saveSettingsDebounced();
-}
-function onMemorySummaryPromptRoleInput() {
-    const value = $(this).val();
-    extension_settings.memory.summaryPromptRole = Number(value);
-    saveSettingsDebounced();
-}
-function onMemoryPositionChange(e) {
-    const value = e.target.value;
-    extension_settings.memory.position = value;
-    reinsertMemory();
-    saveSettingsDebounced();
-}
-function onMemoryIncludeWIScanInput() {
-    const value = !!$(this).prop('checked');
-    extension_settings.memory.scan = value;
-    reinsertMemory();
-    saveSettingsDebounced();
-}
-function onMemoryPromptWordsForceInput() {
-    const value = $(this).val();
-    extension_settings.memory.promptForceWords = Number(value);
-    $('#memory_prompt_words_force_value').text(extension_settings.memory.promptForceWords);
-    saveSettingsDebounced();
-}
-function onOverrideResponseLengthInput() {
-    const value = $(this).val();
-    extension_settings.memory.overrideResponseLength = Number(value);
-    $('#memory_override_response_length_value').text(extension_settings.memory.overrideResponseLength);
-    saveSettingsDebounced();
-}
-function onMaxMessagesPerRequestInput() {
-    const value = $(this).val();
-    extension_settings.memory.maxMessagesPerRequest = Number(value);
-    $('#memory_max_messages_per_request_value').text(extension_settings.memory.maxMessagesPerRequest);
-    saveSettingsDebounced();
-}
-/**
- * Get the latest memory summary from the chat.
- * @param {ChatMessage[]} chat Chat messages
- * @returns {string} Latest memory summary or empty string
- */
-function getLatestMemoryFromChat(chat) {
-    if (!Array.isArray(chat) || !chat.length) {
-        return '';
-    }
-    const reversedChat = chat.slice().reverse();
-    reversedChat.shift();
-    for (let mes of reversedChat) {
-        if (mes.extra && mes.extra.memory) {
-            return mes.extra.memory;
-        }
-    }
-    return '';
-}
-/**
- * Get the index of the latest memory summary from the chat.
- * @param {ChatMessage[]} chat Chat messages
- * @returns {number} Index of the latest memory summary or -1 if not found
- */
-function getIndexOfLatestChatSummary(chat) {
-    if (!Array.isArray(chat) || !chat.length) {
-        return -1;
-    }
-    const reversedChat = chat.slice().reverse();
-    reversedChat.shift();
-    for (let mes of reversedChat) {
-        if (mes.extra && mes.extra.memory) {
-            return chat.indexOf(mes);
-        }
-    }
-    return -1;
-}
-/**
- * Check if something is changed during the summarization process.
- * @param {{ groupId: any; chatId: any; characterId: any; }} context
- * @returns {boolean} True if the context has changed and the summary should be discarded
- */
-function isContextChanged(context) {
-    const newContext = getContext();
-    if (newContext.groupId !== context.groupId
-        || newContext.chatId !== context.chatId
-        || (!newContext.groupId && (newContext.characterId !== context.characterId))) {
-        console.log('Context changed, summary discarded');
-        return true;
-    }
-    return false;
-}
-function onChatChanged() {
-    const context = getContext();
-    const latestMemory = getLatestMemoryFromChat(context.chat);
-    setMemoryContext(latestMemory, false);
-}
-async function onChatEvent() {
-    // Module not enabled
-    if (extension_settings.memory.source === summary_sources.extras && !modules.includes('summarize')) {
-        return;
-    }
-    // WebLLM is not supported
-    if (extension_settings.memory.source === summary_sources.webllm && !isWebLlmSupported()) {
-        return;
-    }
-    // Streaming in-progress
-    if (streamingProcessor && !streamingProcessor.isFinished) {
-        return;
-    }
-    // Currently summarizing or frozen state - skip
-    if (inApiCall || extension_settings.memory.memoryFrozen) {
-        return;
-    }
-    const context = getContext();
-    const chat = context.chat;
-    // Chat can't be empty.
-    if (chat.length === 0) return;
-    const lastMessage = chat[chat.length - 1];
-    // No new messages - do nothing
-    if ((lastMessageId === chat.length && getStringHash(lastMessage.mes) === lastMessageHash)) {
-        return;
-    }
-    // Messages has been deleted - rewrite the context with the latest available memory
-    if (chat.length < lastMessageId) {
-        const latestMemory = getLatestMemoryFromChat(chat);
-        setMemoryContext(latestMemory, false);
-    }
-    // Message has been edited / regenerated - delete the saved memory
-    if (chat.length
-        && lastMessage.extra
-        && lastMessage.extra.memory
-        && lastMessageId === chat.length
-        && getStringHash(lastMessage.mes) !== lastMessageHash) {
-        delete lastMessage.extra.memory;
-    }
-    summarizeChat(context)
-        .catch(console.error)
-        .finally(() => {
-            lastMessageId = context.chat?.length ?? null;
-            lastMessageHash = getStringHash((context.chat.length && context.chat[context.chat.length - 1].mes) ?? '');
-        });
-}
-/**
- * Forces a summary generation for the current chat.
- * @param {boolean} quiet If an informational toast should be displayed
- * @returns {Promise<string>} Summarized text
- */
-async function forceSummarizeChat(quiet) {
-    if (extension_settings.memory.source === summary_sources.extras) {
-        toastr.warning('Force summarization is not supported for Extras API');
-        return;
-    }
-    const context = getContext();
-    const skipWIAN = extension_settings.memory.SkipWIAN;
-    const toast = quiet ? jQuery() : toastr.info('Summarizing chat...', 'Please wait', { timeOut: 0, extendedTimeOut: 0 });
-    const value = extension_settings.memory.source === summary_sources.main
-        ? await summarizeChatMain(context, true, skipWIAN)
-        : await summarizeChatWebLLM(context, true);
-    toastr.clear(toast);
-    if (!value) {
-        toastr.warning('Failed to summarize chat');
-        return '';
-    }
-    return value;
-}
-/**
- * Callback for the summarize command.
- * @param {object} args Command arguments
- * @param {string} text Text to summarize
- */
-async function summarizeCallback(args, text) {
-    text = text.trim();
-    // Summarize the current chat if no text provided
-    if (!text) {
-        const quiet = isTrueBoolean(args.quiet);
-        return await forceSummarizeChat(quiet);
-    }
-    const source = args.source || extension_settings.memory.source;
-    const prompt = substituteParamsExtended((args.prompt || extension_settings.memory.prompt), { words: extension_settings.memory.promptWords });
-    const useUserRole = getSummaryPromptRole() === extension_prompt_roles.USER;
-    try {
-        switch (source) {
-            case summary_sources.extras:
-                return await callExtrasSummarizeAPI(text);
-            case summary_sources.main: {
-                // When the instruction should be a USER message, combine it into the
-                // user content and clear the system prompt. Otherwise keep it as system.
-                const rawPrompt = useUserRole ? [prompt, text].filter(x => x).join('\n\n') : text;
-                const systemPrompt = useUserRole ? '' : prompt;
-                return removeReasoningFromString(await generateRaw({ prompt: rawPrompt, systemPrompt: systemPrompt, responseLength: extension_settings.memory.overrideResponseLength }));
-            }
-            case summary_sources.webllm: {
-                const promptRole = useUserRole ? 'user' : 'system';
-                const messages = [{ role: promptRole, content: prompt }, { role: 'user', content: text }].filter(m => m.content);
-                const params = extension_settings.memory.overrideResponseLength > 0 ? { max_tokens: extension_settings.memory.overrideResponseLength } : {};
-                return await generateWebLlmChatPrompt(messages, params);
-            }
-            default:
-                toastr.warning('Invalid summarization source specified');
-                return '';
-        }
-    } catch (error) {
-        toastr.error(String(error), 'Failed to summarize text');
-        console.log(error);
-        return '';
-    }
-}
-async function summarizeChat(context) {
-    const skipWIAN = extension_settings.memory.SkipWIAN;
-    switch (extension_settings.memory.source) {
-        case summary_sources.extras:
-            await summarizeChatExtras(context);
-            break;
-        case summary_sources.main:
-            await summarizeChatMain(context, false, skipWIAN);
-            break;
-        case summary_sources.webllm:
-            await summarizeChatWebLLM(context, false);
-            break;
-        default:
-            break;
-    }
-}
-/**
- * Check if the chat should be summarized based on the current conditions.
- * Return summary prompt if it should be summarized.
- * @param {any} context ST context
- * @param {boolean} force Summarize the chat regardless of the conditions
- * @returns {Promise<string>} Summary prompt or empty string
- */
-async function getSummaryPromptForNow(context, force) {
-    if (extension_settings.memory.promptInterval === 0 && !force) {
-        console.debug('Prompt interval is set to 0, skipping summarization');
-        return '';
-    }
-    try {
-        // Wait for group to finish generating
-        if (selected_group) {
-            await waitUntilCondition(() => is_group_generating === false, 1000, 10);
-        }
-        // Wait for the send button to be released
-        await waitUntilCondition(() => is_send_press === false, 30000, 100);
-    } catch {
-        console.debug('Timeout waiting for is_send_press');
-        return '';
-    }
-    if (!context.chat.length) {
-        console.debug('No messages in chat to summarize');
-        return '';
-    }
-    if (context.chat.length < extension_settings.memory.promptInterval && !force) {
-        console.debug(`Not enough messages in chat to summarize (chat: ${context.chat.length}, interval: ${extension_settings.memory.promptInterval})`);
-        return '';
-    }
-    let messagesSinceLastSummary = 0;
-    let wordsSinceLastSummary = 0;
-    let conditionSatisfied = false;
-    for (let i = context.chat.length - 1; i >= 0; i--) {
-        if (context.chat[i].extra && context.chat[i].extra.memory) {
-            break;
-        }
-        messagesSinceLastSummary++;
-        wordsSinceLastSummary += extractAllWords(context.chat[i].mes).length;
-    }
-    if (messagesSinceLastSummary >= extension_settings.memory.promptInterval) {
-        conditionSatisfied = true;
-    }
-    if (extension_settings.memory.promptForceWords && wordsSinceLastSummary >= extension_settings.memory.promptForceWords) {
-        conditionSatisfied = true;
-    }
-    if (!conditionSatisfied && !force) {
-        console.debug(`Summary conditions not satisfied (messages: ${messagesSinceLastSummary}, interval: ${extension_settings.memory.promptInterval}, words: ${wordsSinceLastSummary}, force words: ${extension_settings.memory.promptForceWords})`);
-        return '';
-    }
-    console.log('Summarizing chat, messages since last summary: ' + messagesSinceLastSummary, 'words since last summary: ' + wordsSinceLastSummary);
-    const prompt = substituteParamsExtended(extension_settings.memory.prompt, { words: extension_settings.memory.promptWords });
-    if (!prompt) {
-        console.debug('Summarization prompt is empty. Skipping summarization.');
-        return '';
-    }
-    return prompt;
-}
-async function summarizeChatWebLLM(context, force) {
-    if (!isWebLlmSupported()) {
-        return;
-    }
-    const prompt = await getSummaryPromptForNow(context, force);
-    if (!prompt) {
-        return;
-    }
-    const { rawPrompt, lastUsedIndex } = await getRawSummaryPrompt(context, prompt);
-    if (lastUsedIndex === null || lastUsedIndex === -1) {
-        if (force) {
-            toastr.info('To try again, remove the latest summary.', 'No messages found to summarize');
-        }
-        return null;
-    }
-    const promptRole = getSummaryPromptRole() === extension_prompt_roles.USER ? 'user' : 'system';
-    const messages = [
-        { role: promptRole, content: prompt },
-        { role: 'user', content: rawPrompt },
-    ];
-    const params = {};
-    if (extension_settings.memory.overrideResponseLength > 0) {
-        params.max_tokens = extension_settings.memory.overrideResponseLength;
-    }
-    try {
-        inApiCall = true;
-        const summary = await generateWebLlmChatPrompt(messages, params);
-        if (!summary) {
-            console.warn('Empty summary received');
-            return;
-        }
-        // something changed during summarization request
-        if (isContextChanged(context)) {
-            return;
-        }
-        setMemoryContext(summary, true, lastUsedIndex);
-        return summary;
-    } finally {
-        inApiCall = false;
-    }
-}
-// Warn at most once per session if a summary connection profile is selected but cannot be
-// applied because there is no active connection profile to restore afterward.
-let summaryProfileWarnedNoBaseProfile = false;
-/**
- * Runs a callback with a specific Connection Manager profile temporarily active, then restores
- * the previously active profile. This lets the summary be generated by the chosen LLM using the
- * full summarization pipeline (generateQuietPrompt/generateRaw) under that connection, instead of
- * a context-free Connection Manager request that some providers run with the wrong model.
- *
- * The switch is only performed when a real connection profile is currently active (so it can be
- * reliably restored). When none is active — i.e. the user drives the API panel manually —
- * switching to a profile could not be undone without clobbering those manual settings, so we leave
- * the active model in place and warn once.
- *
- * @param {string} targetProfileId Profile to activate for the duration of the callback.
- * @param {() => Promise<any>} callback Work to run while the target profile is active.
- * @returns {Promise<any>} The callback's result.
- */
-async function withConnectionProfile(targetProfileId, callback) {
-    const select = /** @type {HTMLSelectElement} */ (document.getElementById('connection_profiles'));
-    const connectionManager = extension_settings.connectionManager;
-    const currentProfileId = connectionManager?.selectedProfile;
-    const canSwitch = !!select
-        && !!connectionManager
-        && Array.isArray(connectionManager.profiles)
-        && connectionManager.profiles.some(p => p.id === targetProfileId)
-        && Array.from(select.options).some(o => o.value === targetProfileId)
-        && !!currentProfileId // a real profile is active, so it can be restored afterwards
-        && currentProfileId !== targetProfileId;
-    if (!canSwitch) {
-        // Selected but no base profile to restore from -> use the active model and warn once.
-        if (targetProfileId && !currentProfileId && !summaryProfileWarnedNoBaseProfile) {
-            summaryProfileWarnedNoBaseProfile = true;
-            toastr.info('The summary connection profile is only applied while a connection profile is active (so the original can be restored). Using the current model.', 'Summarize');
-        }
-        return await callback();
-    }
-    const switchToProfile = async (profileId) => {
-        const loaded = new Promise(resolve => eventSource.once(event_types.CONNECTION_PROFILE_LOADED, resolve));
-        const timeout = new Promise(resolve => setTimeout(resolve, 10000));
-        const index = Array.from(select.options).findIndex(o => o.value === profileId);
-        select.selectedIndex = index >= 0 ? index : 0;
-        select.dispatchEvent(new Event('change'));
-        // Wait for the profile's commands to finish applying (don't hang forever if the event never fires).
-        await Promise.race([loaded, timeout]);
-        // Applying a profile reconnects the API asynchronously; generating before it is
-        // re-established fails instantly, so wait for the connection to come back up
-        // (mirrors the built-in /profile command). rejectOnTimeout:false -> proceed anyway after the timeout.
-        await waitUntilCondition(() => online_status !== 'no_connection', 10000, 100, { rejectOnTimeout: false });
-    };
-    await switchToProfile(targetProfileId);
-    try {
-        return await callback();
-    } finally {
-        try {
-            await switchToProfile(currentProfileId);
-        } catch (err) {
-            console.error('Summarize: failed to restore the previous connection profile after summarization', err);
-        }
-    }
-}
-async function summarizeChatMain(context, force, skipWIAN) {
-    const prompt = await getSummaryPromptForNow(context, force);
-    if (!prompt) {
-        return;
-    }
-    console.log('sending summary prompt');
-    // Runs the configured summary builder (DEFAULT or RAW) against whatever connection is
-    // currently active. Returns { summary, index }, or null when there is nothing to summarize.
-    const runConfiguredSummary = async () => {
-        let summary = '';
-        let index = null;
-        if (prompt_builders.DEFAULT === extension_settings.memory.prompt_builder) {
-            // generateQuietPrompt always injects the instruction as a SYSTEM message
-            // (the QUIET_PROMPT extension prompt has no exposed role parameter).
-            // When a USER role is requested, assemble the chat transcript ourselves
-            // (same source as the raw builder) and deliver the instruction as USER
-            // content via generateRaw, so the model still receives the chat to
-            // summarize instead of just the bare instruction.
-            if (getSummaryPromptRole() === extension_prompt_roles.USER) {
-                const { rawPrompt } = await getRawSummaryPrompt(context, prompt);
-                /** @type {import('../../../script.js').GenerateRawParams} */
-                const params = {
-                    prompt: [prompt, rawPrompt].filter(x => x).join('\n\n'),
-                    systemPrompt: '',
-                    responseLength: extension_settings.memory.overrideResponseLength,
-                };
-                summary = removeReasoningFromString(await generateRaw(params));
-            } else {
-                /** @type {import('../../../script.js').GenerateQuietPromptParams} */
-                const params = {
-                    quietPrompt: prompt,
-                    skipWIAN: skipWIAN,
-                    responseLength: extension_settings.memory.overrideResponseLength,
-                };
-                summary = await generateQuietPrompt(params);
-            }
-        }
-        if ([prompt_builders.RAW_BLOCKING, prompt_builders.RAW_NON_BLOCKING].includes(extension_settings.memory.prompt_builder)) {
-            const lock = extension_settings.memory.prompt_builder === prompt_builders.RAW_BLOCKING;
-            try {
-                if (lock) {
-                    deactivateSendButtons();
-                }
-                const { rawPrompt, lastUsedIndex } = await getRawSummaryPrompt(context, prompt);
-                if (lastUsedIndex === null || lastUsedIndex === -1) {
-                    if (force) {
-                        toastr.info('To try again, remove the latest summary.', 'No messages found to summarize');
-                    }
-                    return null;
-                }
-                // When the summary instruction should be a USER message, deliver it as
-                // user content and leave the system prompt empty. Otherwise keep the
-                // existing behavior of sending it as the system prompt.
-                const useUserRole = getSummaryPromptRole() === extension_prompt_roles.USER;
-                /** @type {import('../../../script.js').GenerateRawParams} */
-                const params = {
-                    prompt: useUserRole ? [prompt, rawPrompt].filter(x => x).join('\n\n') : rawPrompt,
-                    systemPrompt: useUserRole ? '' : prompt,
-                    responseLength: extension_settings.memory.overrideResponseLength,
-                };
-                const rawSummary = await generateRaw(params);
-                summary = removeReasoningFromString(rawSummary);
-                index = lastUsedIndex;
-            } finally {
-                if (lock) {
-                    activateSendButtons();
-                }
-            }
-        }
-        return { summary, index };
-    };
-    // A dedicated connection profile generates the summary with the chosen LLM by temporarily
-    // switching the active connection profile (so the full summarization pipeline runs under it),
-    // then restoring the previous profile. Falls back to the active model when no profile is set
-    // or no base profile is active to restore.
-    const summaryConnectionProfile = extension_settings.memory.summaryConnectionProfile;
-    let result;
-    try {
-        inApiCall = true;
-        result = summaryConnectionProfile
-            ? await withConnectionProfile(summaryConnectionProfile, runConfiguredSummary)
-            : await runConfiguredSummary();
-    } finally {
-        inApiCall = false;
-    }
-    if (result === null) {
-        return null;
-    }
-    const { summary, index } = result;
-    if (!summary) {
-        console.warn('Empty summary received');
-        return;
-    }
-    if (isContextChanged(context)) {
-        return;
-    }
-    setMemoryContext(summary, true, index);
-    return summary;
-}
-/**
- * Get the raw summarization prompt from the chat context.
- * @param {object} context ST context
- * @param {string} prompt Summarization system prompt
- * @returns {Promise<{rawPrompt: string, lastUsedIndex: number}>} Raw summarization prompt
- */
-async function getRawSummaryPrompt(context, prompt) {
-    /**
-     * Get the memory string from the chat buffer.
-     * @param {boolean} includeSystem Include prompt into the memory string
-     * @returns {string} Memory string
-     */
-    function getMemoryString(includeSystem) {
-        const delimiter = '\n\n';
-        const stringBuilder = [];
-        const bufferString = chatBuffer.slice().join(delimiter);
-        if (includeSystem) {
-            stringBuilder.push(prompt);
-        }
-        if (latestSummary) {
-            stringBuilder.push(latestSummary);
-        }
-        stringBuilder.push(bufferString);
-        return stringBuilder.join(delimiter).trim();
-    }
-    const chat = context.chat.slice();
-    const latestSummary = getLatestMemoryFromChat(chat);
-    const latestSummaryIndex = getIndexOfLatestChatSummary(chat);
-    chat.pop(); // We always exclude the last message from the buffer
-    const chatBuffer = [];
-    const PADDING = 64;
-    const PROMPT_SIZE = await getSourceContextSize();
-    let latestUsedMessage = null;
-    for (let index = latestSummaryIndex + 1; index < chat.length; index++) {
-        const message = chat[index];
-        if (!message) {
-            break;
-        }
-        if (message.is_system || !message.mes) {
-            continue;
-        }
-        const entry = `${message.name}:\n${message.mes}`;
-        chatBuffer.push(entry);
-        const tokens = await countSourceTokens(getMemoryString(true), PADDING);
-        if (tokens > PROMPT_SIZE) {
-            chatBuffer.pop();
-            break;
-        }
-        latestUsedMessage = message;
-        if (extension_settings.memory.maxMessagesPerRequest > 0 && chatBuffer.length >= extension_settings.memory.maxMessagesPerRequest) {
-            break;
-        }
-    }
-    const lastUsedIndex = context.chat.indexOf(latestUsedMessage);
-    const rawPrompt = getMemoryString(false);
-    return { rawPrompt, lastUsedIndex };
-}
-async function summarizeChatExtras(context) {
-    function getMemoryString() {
-        return (longMemory + '\n\n' + memoryBuffer.slice().reverse().join('\n\n')).trim();
-    }
-    const chat = context.chat;
-    const longMemory = getLatestMemoryFromChat(chat);
-    const reversedChat = chat.slice().reverse();
-    reversedChat.shift();
-    const memoryBuffer = [];
-    const CONTEXT_SIZE = await getSourceContextSize();
-    for (const message of reversedChat) {
-        // we reached the point of latest memory
-        if (longMemory && message.extra && message.extra.memory == longMemory) {
-            break;
-        }
-        // don't care about system
-        if (message.is_system) {
-            continue;
-        }
-        // determine the sender's name
-        const entry = `${message.name}:\n${message.mes}`;
-        memoryBuffer.push(entry);
-        // check if token limit was reached
-        const tokens = await countSourceTokens(getMemoryString());
-        if (tokens >= CONTEXT_SIZE) {
-            break;
-        }
-    }
-    const resultingString = getMemoryString();
-    const resultingTokens = await countSourceTokens(resultingString);
-    if (!resultingString || resultingTokens < CONTEXT_SIZE) {
-        console.debug('Not enough context to summarize');
-        return;
-    }
-    // perform the summarization API call
-    try {
-        inApiCall = true;
-        const summary = await callExtrasSummarizeAPI(resultingString);
-        if (!summary) {
-            console.warn('Empty summary received');
-            return;
-        }
-        if (isContextChanged(context)) {
-            return;
-        }
-        setMemoryContext(summary, true);
-    } catch (error) {
-        console.log(error);
-    } finally {
-        inApiCall = false;
-    }
-}
-/**
- * Call the Extras API to summarize the provided text.
- * @param {string} text Text to summarize
- * @returns {Promise<string>} Summarized text
- */
-async function callExtrasSummarizeAPI(text) {
-    if (!modules.includes('summarize')) {
-        throw new Error('Summarize module is not enabled in Extras API');
-    }
-    const url = new URL(getApiUrl());
-    url.pathname = '/api/summarize';
-    const apiResult = await doExtrasFetch(url, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'Bypass-Tunnel-Reminder': 'bypass',
-        },
-        body: JSON.stringify({
-            text: text,
-            params: {},
-        }),
-    });
-    if (apiResult.ok) {
-        const data = await apiResult.json();
-        const summary = data.summary;
-        return summary;
-    }
-    throw new Error('Extras API call failed');
-}
-function onMemoryRestoreClick() {
-    const context = getContext();
-    const content = $('#memory_contents').val();
-    const reversedChat = context.chat.slice().reverse();
-    reversedChat.shift();
-    for (let mes of reversedChat) {
-        if (mes.extra && mes.extra.memory == content) {
-            delete mes.extra.memory;
-            break;
-        }
-    }
-    const newContent = getLatestMemoryFromChat(context.chat);
-    setMemoryContext(newContent, false);
-}
-function onMemoryContentInput() {
-    const value = $(this).val();
-    setMemoryContext(value, true);
-}
-function onMemoryPromptBuilderInput(e) {
-    const value = Number(e.target.value);
-    extension_settings.memory.prompt_builder = value;
-    saveSettingsDebounced();
-}
-function reinsertMemory() {
-    const existingValue = String($('#memory_contents').val());
-    setMemoryContext(existingValue, false);
-}
-/**
- * Set the summary value to the context and save it to the chat message extra.
- * @param {string} value Value of a summary
- * @param {boolean} saveToMessage Should the summary be saved to the chat message extra
- * @param {number|null} index Index of the chat message to save the summary to. If null, the pre-last message is used.
- */
-function setMemoryContext(value, saveToMessage, index = null) {
-    setExtensionPrompt(MODULE_NAME, formatMemoryValue(value), extension_settings.memory.position, extension_settings.memory.depth, extension_settings.memory.scan, extension_settings.memory.role);
-    $('#memory_contents').val(value);
-    const summaryLog = value
-        ? `Summary set to: ${value}. Position: ${extension_settings.memory.position}. Depth: ${extension_settings.memory.depth}. Role: ${extension_settings.memory.role}`
-        : 'Summary has no content';
-    console.debug(summaryLog);
-    const context = getContext();
-    if (saveToMessage && context.chat.length) {
-        const idx = index ?? context.chat.length - 2;
-        const mes = context.chat[idx < 0 ? 0 : idx];
-        if (!mes.extra) {
-            mes.extra = {};
-        }
-        mes.extra.memory = value;
-        saveChatDebounced();
-    }
-}
-function doPopout(e) {
-    const target = e.target;
-    //repurposes the zoomed avatar template to server as a floating div
-    if ($('#summaryExtensionPopout').length === 0) {
-        console.debug('did not see popout yet, creating');
-        const originalHTMLClone = $(target).parent().parent().parent().find('.inline-drawer-content').html();
-        const originalElement = $(target).parent().parent().parent().find('.inline-drawer-content');
-        const template = $('#zoomed_avatar_template').html();
-        const controlBarHtml = `<div class="panelControlBar flex-container">
-        <div id="summaryExtensionPopoutheader" class="fa-solid fa-grip drag-grabber hoverglow"></div>
-        <div id="summaryExtensionPopoutClose" class="fa-solid fa-circle-xmark hoverglow dragClose"></div>
-    </div>`;
-        const newElement = $(template);
-        newElement.attr('id', 'summaryExtensionPopout')
-            .css('opacity', 0)
-            .removeClass('zoomed_avatar')
-            .addClass('draggable')
-            .empty();
-        const prevSummaryBoxContents = $('#memory_contents').val().toString(); //copy summary box before emptying
-        originalElement.empty();
-        originalElement.html('<div class="flex-container alignitemscenter justifyCenter wide100p"><small>Currently popped out</small></div>');
-        newElement.append(controlBarHtml).append(originalHTMLClone);
-        $('#movingDivs').append(newElement);
-        newElement.transition({ opacity: 1, duration: animation_duration, easing: animation_easing });
-        $('#summaryExtensionDrawerContents').addClass('scrollableInnerFull');
-        setMemoryContext(prevSummaryBoxContents, false); //paste prev summary box contents into popout box
-        setupListeners();
-        loadSettings();
-        loadMovingUIState();
-        dragElement(newElement);
-        //setup listener for close button to restore extensions menu
-        $('#summaryExtensionPopoutClose').off('click').on('click', function () {
-            $('#summaryExtensionDrawerContents').removeClass('scrollableInnerFull');
-            const summaryPopoutHTML = $('#summaryExtensionDrawerContents');
-            $('#summaryExtensionPopout').fadeOut(animation_duration, () => {
-                originalElement.empty();
-                originalElement.append(summaryPopoutHTML);
-                $('#summaryExtensionPopout').remove();
-            });
-            loadSettings();
-        });
-    } else {
-        console.debug('saw existing popout, removing');
-        $('#summaryExtensionPopout').fadeOut(animation_duration, () => { $('#summaryExtensionPopoutClose').trigger('click'); });
-    }
-}
-function setupListeners() {
-    //setup shared listeners for popout and regular ext menu
-    $('#memory_restore').off('click').on('click', onMemoryRestoreClick);
-    $('#memory_contents').off('input').on('input', onMemoryContentInput);
-    $('#memory_frozen').off('input').on('input', onMemoryFrozenInput);
-    $('#memory_skipWIAN').off('input').on('input', onMemorySkipWIANInput);
-    $('#summary_source').off('change').on('change', onSummarySourceChange);
-    $('#memory_prompt_words').off('input').on('input', onMemoryPromptWordsInput);
-    $('#memory_prompt_interval').off('input').on('input', onMemoryPromptIntervalInput);
-    $('#memory_prompt').off('input').on('input', onMemoryPromptInput);
-    $('#memory_force_summarize').off('click').on('click', () => forceSummarizeChat(false));
-    $('#memory_template').off('input').on('input', onMemoryTemplateInput);
-    $('#memory_depth').off('input').on('input', onMemoryDepthInput);
-    $('#memory_role').off('input').on('input', onMemoryRoleInput);
-    $('#memory_summary_prompt_role').off('input').on('input', onMemorySummaryPromptRoleInput);
-    $('input[name="memory_position"]').off('change').on('change', onMemoryPositionChange);
-    $('#memory_prompt_words_force').off('input').on('input', onMemoryPromptWordsForceInput);
-    $('#memory_prompt_builder_default').off('input').on('input', onMemoryPromptBuilderInput);
-    $('#memory_prompt_builder_raw_blocking').off('input').on('input', onMemoryPromptBuilderInput);
-    $('#memory_prompt_builder_raw_non_blocking').off('input').on('input', onMemoryPromptBuilderInput);
-    $('#memory_prompt_restore').off('click').on('click', onMemoryPromptRestoreClick);
-    $('#memory_prompt_interval_auto').off('click').on('click', onPromptIntervalAutoClick);
-    $('#memory_prompt_words_auto').off('click').on('click', onPromptForceWordsAutoClick);
-    $('#memory_override_response_length').off('input').on('input', onOverrideResponseLengthInput);
-    $('#memory_max_messages_per_request').off('input').on('input', onMaxMessagesPerRequestInput);
-    $('#memory_include_wi_scan').off('input').on('input', onMemoryIncludeWIScanInput);
-    $('#summarySettingsBlockToggle').off('click').on('click', function () {
-        $('#summarySettingsBlock').slideToggle(200, 'swing');
-    });
-}
-export async function init() {
-    async function addExtensionControls() {
-        const settingsHtml = await renderExtensionTemplateAsync('memory', 'settings', { defaultSettings });
-        $('#summarize_container').append(settingsHtml);
-        setupListeners();
-        $('#summaryExtensionPopoutButton').off('click').on('click', function (e) {
-            doPopout(e);
-            e.stopPropagation();
-        });
-    }
-    await addExtensionControls();
-    loadSettings();
-    eventSource.on(event_types.CHAT_CHANGED, onChatChanged);
-    eventSource.makeLast(event_types.CHARACTER_MESSAGE_RENDERED, onChatEvent);
-    for (const event of [event_types.MESSAGE_DELETED, event_types.MESSAGE_UPDATED, event_types.MESSAGE_SWIPED]) {
-        eventSource.on(event, onChatEvent);
-    }
-    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
-        name: 'summarize',
-        callback: summarizeCallback,
-        namedArgumentList: [
-            new SlashCommandNamedArgument('source', 'API to use for summarization', [ARGUMENT_TYPE.STRING], false, false, '', Object.values(summary_sources)),
-            SlashCommandNamedArgument.fromProps({
-                name: 'prompt',
-                description: 'prompt to use for summarization',
-                typeList: [ARGUMENT_TYPE.STRING],
-                defaultValue: '',
-            }),
-            SlashCommandNamedArgument.fromProps({
-                name: 'quiet',
-                description: 'suppress the toast message when summarizing the chat',
-                typeList: [ARGUMENT_TYPE.BOOLEAN],
-                defaultValue: 'false',
-                enumList: commonEnumProviders.boolean('trueFalse')(),
-            }),
-        ],
-        unnamedArgumentList: [
-            new SlashCommandArgument('text to summarize', [ARGUMENT_TYPE.STRING], false, false, ''),
-        ],
-        helpString: 'Summarizes the given text. If no text is provided, the current chat will be summarized. Can specify the source and the prompt to use.',
-        returns: ARGUMENT_TYPE.STRING,
-    }));
-    const summaryMacroHandler = () => {
-        // Checking content of the UI summary box first
-        const uiSummary = $('#memory_contents').val().toString();
-        if (uiSummary.trim().length > 0) {
-            return uiSummary;
-        }
-        // Fallback to scanning the chat for the latest summary if the UI summary box is empty
-        return getLatestMemoryFromChat(getContext().chat);
-    };
-    if (power_user.experimental_macro_engine) {
-        macros.register('summary', {
-            category: MacroCategory.CHAT,
-            description: 'Returns the latest memory/summary from the current chat.',
-            handler: () => summaryMacroHandler(),
-        });
-    } else {
-        // TODO: Remove this when the experimental macro engine is replacing the old macro engine
-        MacrosParser.registerMacro('summary',
-            () => summaryMacroHandler(),
-            'Returns the latest memory/summary from the current chat.');
-    }
-}

public/scripts/extensions/memory/manifest.json+0 -16 Viewed

-{
-    "display_name": "Summarize",
-    "loading_order": 9,
-    "requires": [],
-    "optional": [
-        "summarize"
-    ],
-    "js": "index.js",
-    "css": "style.css",
-    "author": "Cohee#1207",
-    "version": "1.0.0",
-    "homePage": "https://github.com/SillyTavern/SillyTavern",
-    "hooks": {
-        "activate": "init"
-    }
-}

public/scripts/extensions/memory/settings.html+0 -157 Viewed

-<div id="memory_settings">
-    <div class="inline-drawer">
-        <div class="inline-drawer-toggle inline-drawer-header">
-            <div class="flex-container alignitemscenter margin0">
-                <b data-i18n="ext_sum_title">Summarize</b>
-                <i id="summaryExtensionPopoutButton" class="fa-solid fa-window-restore menu_button margin0"></i>
-            </div>
-            <div class="inline-drawer-icon fa-solid fa-circle-chevron-down down"></div>
-        </div>
-        <div class="inline-drawer-content">
-            <div id="summaryExtensionDrawerContents">
-                <label for="summary_source" data-i18n="ext_sum_with">Summarize with:</label>
-                <select id="summary_source" class="text_pole">
-                    <option value="main" data-i18n="ext_sum_main_api">Main API</option>
-                    <option value="extras">Extras API (deprecated)</option>
-                    <option value="webllm" data-i18n="ext_sum_webllm">WebLLM Extension</option>
-                </select><br>
-                <div class="flex-container justifyspacebetween alignitemscenter">
-                    <span data-i18n="ext_sum_current_summary">Current summary:</span>
-                    <i class="editor_maximize fa-solid fa-maximize right_menu_button" data-for="memory_contents" title="Expand the editor" data-i18n="[title]Expand the editor"></i>
-                    <span class="flex1">&nbsp;</span>
-                    <div id="memory_restore" class="menu_button margin0" data-i18n="[title]ext_sum_restore_tip" title="Restore a previous summary; use repeatedly to clear summarization state for this chat.">
-                        <small data-i18n="ext_sum_restore_previous">Restore Previous</small>
-                    </div>
-                </div>
-                <textarea id="memory_contents" class="text_pole textarea_compact" rows="6" data-i18n="[placeholder]ext_sum_memory_placeholder" placeholder="Summary will be generated here..."></textarea>
-                <div class="memory_contents_controls">
-                    <div id="memory_force_summarize" data-summary-source="main,webllm" class="menu_button menu_button_icon" title="Trigger a summary update right now." data-i18n="[title]ext_sum_force_tip">
-                        <i class="fa-solid fa-database"></i>
-                        <span data-i18n="ext_sum_force_text">Summarize now</span>
-                    </div>
-                    <label for="memory_frozen" title="Disable automatic summary updates. While paused, the summary remains as-is. You can still force an update by pressing the Summarize now button (which is only available with the Main API)." data-i18n="[title]Disable automatic summary updates. While paused, the summary remains as-is. You can still force an update by pressing the Summarize now button (which is only available with the Main API)."><input id="memory_frozen" type="checkbox" /><span data-i18n="ext_sum_pause">Pause</span></label>
-                    <label data-summary-source="main" for="memory_skipWIAN" title="Omit World Info and Author's Note from text to be summarized. Only has an effect when using the Main API. The Extras API always omits WI/AN." data-i18n="[title]Omit World Info and Author's Note from text to be summarized. Only has an effect when using the Main API. The Extras API always omits WI/AN.">
-                        <input id="memory_skipWIAN" type="checkbox" />
-                        <span data-i18n="ext_sum_no_wi_an">No WI/AN</span>
-                    </label>
-                </div>
-                <div class="memory_contents_controls">
-                    <div id="summarySettingsBlockToggle" class="menu_button menu_button_icon" data-i18n="[title]ext_sum_settings_tip" title="Edit summarization prompt, insertion position, etc.">
-                        <i class="fa-solid fa-cog"></i>
-                        <span data-i18n="ext_sum_settings">Summary Settings</span>
-                    </div>
-                </div>
-                <div id="summarySettingsBlock" style="display:none;">
-                    <div data-summary-source="main">
-                        <label data-i18n="ext_sum_prompt_builder">
-                            Prompt builder
-                        </label>
-                        <label class="checkbox_label" for="memory_prompt_builder_raw_blocking" data-i18n="[title]ext_sum_prompt_builder_1_desc" title="Extension will build its own prompt using messages that were not summarized yet. Blocks the chat until the summary is generated.">
-                            <input id="memory_prompt_builder_raw_blocking" type="radio" name="memory_prompt_builder" value="1" />
-                            <span data-i18n="ext_sum_prompt_builder_1">Raw, blocking</span>
-                        </label>
-                        <label class="checkbox_label" for="memory_prompt_builder_raw_non_blocking" data-i18n="[title]ext_sum_prompt_builder_2_desc" title="Extension will build its own prompt using messages that were not summarized yet. Does not block the chat while the summary is being generated. Not all backends support this mode.">
-                            <input id="memory_prompt_builder_raw_non_blocking" type="radio" name="memory_prompt_builder" value="2" />
-                            <span data-i18n="ext_sum_prompt_builder_2">Raw, non-blocking</span>
-                        </label>
-                        <label class="checkbox_label" id="memory_prompt_builder_default" data-i18n="[title]ext_sum_prompt_builder_3_desc" title="Extension will use the regular main prompt builder and add the summary request to it as the last system message.">
-                            <input id="memory_prompt_builder_default" type="radio" name="memory_prompt_builder" value="0" />
-                            <span data-i18n="ext_sum_prompt_builder_3">Classic, blocking</span>
-                        </label>
-                    </div>
-                    <div data-summary-source="main,webllm">
-                        <label for="memory_prompt" class="title_restorable">
-                            <span data-i18n="Summary Prompt">Summary Prompt</span>
-                            <div id="memory_prompt_restore" data-i18n="[title]ext_sum_restore_default_prompt_tip" title="Restore default prompt" class="right_menu_button">
-                                <div class="fa-solid fa-clock-rotate-left"></div>
-                            </div>
-                        </label>
-                        <textarea id="memory_prompt" class="text_pole textarea_compact" rows="6" data-i18n="[placeholder]ext_sum_prompt_placeholder" placeholder="This prompt will be sent to AI to request the summary generation. &lcub;&lcub;words&rcub;&rcub; will resolve to the 'Number of words' parameter."></textarea>
-                        <label for="memory_summary_prompt_role" data-i18n="ext_sum_prompt_role">Summary Prompt Role</label>
-                        <select id="memory_summary_prompt_role" class="text_pole">
-                            <option value="0" data-i18n="System">System</option>
-                            <option value="1" data-i18n="User">User</option>
-                        </select>
-                        <small data-i18n="ext_sum_prompt_role_desc">The role used to send the summary request instruction to the model.</small>
-                        <label for="memory_summary_connection_profile" data-i18n="ext_sum_connection_profile">Summary Connection Profile</label>
-                        <select id="memory_summary_connection_profile" class="text_pole"></select>
-                        <small data-i18n="ext_sum_connection_profile_desc">Summarize with a specific connection profile instead of the active model. Leave empty to use the active model.</small>
-                        <label for="memory_prompt_words"><span data-i18n="ext_sum_target_length_1">Target summary length</span> <span data-i18n="ext_sum_target_length_2">(</span><span id="memory_prompt_words_value"></span><span data-i18n="ext_sum_target_length_3"> words)</span></label>
-                        <input id="memory_prompt_words" type="range" value="{{defaultSettings.promptWords}}" min="{{defaultSettings.promptMinWords}}" max="{{defaultSettings.promptMaxWords}}" step="{{defaultSettings.promptWordsStep}}" />
-                        <label for="memory_override_response_length">
-                            <span data-i18n="ext_sum_api_response_length_1">API response length</span> <span data-i18n="ext_sum_api_response_length_2">(</span><span id="memory_override_response_length_value"></span><span data-i18n="ext_sum_api_response_length_3"> tokens)</span>
-                            <small class="memory_disabled_hint" data-i18n="ext_sum_0_default">0 = default</small>
-                        </label>
-                        <input id="memory_override_response_length" type="range" value="{{defaultSettings.overrideResponseLength}}" min="{{defaultSettings.overrideResponseLengthMin}}" max="{{defaultSettings.overrideResponseLengthMax}}" step="{{defaultSettings.overrideResponseLengthStep}}" />
-                        <label for="memory_max_messages_per_request">
-                            <span data-i18n="ext_sum_raw_max_msg">[Raw/WebLLM] Max messages per request</span> (<span id="memory_max_messages_per_request_value"></span>)
-                            <small class="memory_disabled_hint" data-i18n="ext_sum_0_unlimited">0 = unlimited</small>
-                        </label>
-                        <input id="memory_max_messages_per_request" type="range" value="{{defaultSettings.maxMessagesPerRequest}}" min="{{defaultSettings.maxMessagesPerRequestMin}}" max="{{defaultSettings.maxMessagesPerRequestMax}}" step="{{defaultSettings.maxMessagesPerRequestStep}}" />
-                        <h4 data-i18n="Update frequency" class="textAlignCenter">
-                            Update frequency
-                        </h4>
-                        <label for="memory_prompt_interval" class="title_restorable">
-                            <span>
-                                <span data-i18n="ext_sum_update_every_messages_1">Update every</span> <span id="memory_prompt_interval_value"></span><span data-i18n="ext_sum_update_every_messages_2"> messages</span>
-                                <small class="memory_disabled_hint" data-i18n="ext_sum_0_disable">0 = disable</small>
-                            </span>
-                            <div id="memory_prompt_interval_auto" data-i18n="[title]ext_sum_auto_adjust_desc" title="Try to automatically adjust the interval based on the chat metrics." class="right_menu_button">
-                                <div class="fa-solid fa-wand-magic-sparkles"></div>
-                            </div>
-                        </label>
-                        <input id="memory_prompt_interval" type="range" value="{{defaultSettings.promptInterval}}" min="{{defaultSettings.promptMinInterval}}" max="{{defaultSettings.promptMaxInterval}}" step="{{defaultSettings.promptIntervalStep}}" />
-                        <label for="memory_prompt_words_force" class="title_restorable">
-                            <span>
-                                <span data-i18n="ext_sum_update_every_words_1">Update every</span> <span id="memory_prompt_words_force_value"></span><span data-i18n="ext_sum_update_every_words_2"> words</span>
-                                <small class="memory_disabled_hint" data-i18n="ext_sum_0_disable">0 = disable</small>
-                            </span>
-                            <div id="memory_prompt_words_auto" data-i18n="[title]ext_sum_auto_adjust_desc" title="Try to automatically adjust the interval based on the chat metrics." class="right_menu_button">
-                                <div class="fa-solid fa-wand-magic-sparkles"></div>
-                            </div>
-                        </label>
-                        <input id="memory_prompt_words_force" type="range" value="{{defaultSettings.promptForceWords}}" min="{{defaultSettings.promptMinForceWords}}" max="{{defaultSettings.promptMaxForceWords}}" step="{{defaultSettings.promptForceWordsStep}}" />
-                        <small data-i18n="ext_sum_both_sliders">If both sliders are non-zero, then both will trigger summary updates at their respective intervals.</small>
-                        <hr>
-                    </div>
-                    <div class="memory_template">
-                        <label for="memory_template" data-i18n="ext_sum_injection_template">Injection Template</label>
-                        <textarea id="memory_template" class="text_pole textarea_compact" rows="2" data-i18n="[placeholder]ext_sum_memory_template_placeholder" placeholder="&lcub;&lcub;summary&rcub;&rcub; will resolve to the current summary contents."></textarea>
-                    </div>
-                    <label for="memory_position" data-i18n="ext_sum_injection_position">Injection Position</label>
-                    <label class="checkbox_label" for="memory_include_wi_scan" data-i18n="[title]ext_sum_include_wi_scan_desc" title="Include the latest summary in the WI scan.">
-                        <input id="memory_include_wi_scan" type="checkbox" />
-                        <span data-i18n="ext_sum_include_wi_scan">Include in World Info Scanning</span>
-                    </label>
-                    <div class="radio_group">
-                        <label>
-                            <input type="radio" name="memory_position" value="-1" />
-                            <span data-i18n="None (not injected)">None (not injected)</span>
-                            <i class="fa-solid fa-info-circle" title="The summary will not be injected into the prompt. You can still access it via the &lcub;&lcub;summary&rcub;&rcub; macro." data-i18n="[title]ext_sum_injection_position_none"></i>
-                        </label>
-                        <label>
-                            <input type="radio" name="memory_position" value="2" />
-                            <span data-i18n="Before Main Prompt / Story String">Before Main Prompt / Story String</span>
-                        </label>
-                        <label>
-                            <input type="radio" name="memory_position" value="0" />
-                            <span data-i18n="After Main Prompt / Story String">After Main Prompt / Story String</span>
-                        </label>
-                        <label class="flex-container alignItemsCenter" title="How many messages before the current end of the chat." data-i18n="[title]How many messages before the current end of the chat.">
-                            <input type="radio" name="memory_position" value="1" />
-                            <span data-i18n="In-chat @ Depth">In-chat @ Depth</span> <input id="memory_depth" class="text_pole widthUnset" type="number" min="0" max="9999" />
-                            <span data-i18n="as">as</span>
-                            <select id="memory_role" class="text_pole widthNatural">
-                                <option value="0" data-i18n="System">System</option>
-                                <option value="1" data-i18n="User">User</option>
-                                <option value="2" data-i18n="Assistant">Assistant</option>
-                            </select>
-                        </label>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>

public/scripts/extensions/memory/style.css+0 -47 Viewed

-#memory_settings {
-    display: flex;
-    flex-direction: column;
-}
-#memory_contents {
-    field-sizing: content;
-    max-height: 50dvh;
-}
-#memory_restore {
-    width: max-content;
-}
-label[for="memory_frozen"],
-label[for="memory_skipWIAN"] {
-    display: flex;
-    align-items: center;
-    margin: 0 !important;
-}
-label[for="memory_frozen"] input {
-    margin-right: 10px;
-}
-.memory_contents_controls {
-    display: flex;
-    flex-direction: row;
-    align-items: center;
-    justify-content: space-between;
-}
-.memory_disabled_hint {
-    margin-left: 2px;
-}
-#summarySettingsBlock {
-    display: flex;
-    flex-direction: column;
-    row-gap: 5px;
-}
-#summaryExtensionPopout {
-    display: flex;
-    flex-direction: column;
-    padding-top: 25px;
-}

public/scripts/extensions/stable-diffusion/button.html+0 -4 Viewed

-<div id="sd_gen" class="list-group-item flex-container flexGap5">
-    <div class="fa-solid fa-paintbrush extensionsMenuExtensionButton" title="Trigger Stable Diffusion"  data-i18n="[title]Trigger Stable Diffusion"></div>
-    <span data-i18n="Generate Image">Generate Image</span>
-</div>

public/scripts/extensions/stable-diffusion/comfyWorkflowEditor.html+0 -44 Viewed

-<div id="sd_comfy_workflow_editor_template">
-    <div class="sd_comfy_workflow_editor">
-        <h3><strong>ComfyUI Workflow Editor: <span id="sd_comfy_workflow_editor_name"></span></strong></h3>
-        <div class="sd_comfy_workflow_editor_content">
-            <div class="flex-container flexFlowColumn sd_comfy_workflow_editor_workflow_container">
-                <label for="sd_comfy_workflow_editor_workflow">Workflow (JSON)</label>
-                <textarea id="sd_comfy_workflow_editor_workflow" class="text_pole wide100p textarea_compact flex1" placeholder="Insert your ComfyUI workflow here by copying the JSON data obtained via the 'Save (API Format)' option. This option becomes available after enabling 'Dev Mode' in the settings. Remember to replace specific values within your workflow with placeholders as required for your use case."></textarea>
-            </div>
-            <div class="sd_comfy_workflow_editor_placeholder_container">
-                <div>Placeholders</div>
-                <ul class="sd_comfy_workflow_editor_placeholder_list">
-                    <li data-placeholder="prompt" class="sd_comfy_workflow_editor_not_found">"%prompt%"</li>
-                    <li data-placeholder="negative_prompt" class="sd_comfy_workflow_editor_not_found">"%negative_prompt%"</li>
-                    <li data-placeholder="model" class="sd_comfy_workflow_editor_not_found">"%model%"</li>
-                    <li data-placeholder="vae" class="sd_comfy_workflow_editor_not_found">"%vae%"</li>
-                    <li data-placeholder="lora" class="sd_comfy_workflow_editor_not_found">"%lora%"</li>
-                    <li data-placeholder="lora_strength" class="sd_comfy_workflow_editor_not_found">"%lora_strength%"</li>
-                    <li data-placeholder="sampler" class="sd_comfy_workflow_editor_not_found">"%sampler%"</li>
-                    <li data-placeholder="scheduler" class="sd_comfy_workflow_editor_not_found">"%scheduler%"</li>
-                    <li data-placeholder="steps" class="sd_comfy_workflow_editor_not_found">"%steps%"</li>
-                    <li data-placeholder="scale" class="sd_comfy_workflow_editor_not_found">"%scale%"</li>
-                    <li data-placeholder="denoise" class="sd_comfy_workflow_editor_not_found">"%denoise%"</li>
-                    <li data-placeholder="clip_skip" class="sd_comfy_workflow_editor_not_found">"%clip_skip%"</li>
-                    <li data-placeholder="width" class="sd_comfy_workflow_editor_not_found">"%width%"</li>
-                    <li data-placeholder="height" class="sd_comfy_workflow_editor_not_found">"%height%"</li>
-                    <li data-placeholder="user_avatar" class="sd_comfy_workflow_editor_not_found">"%user_avatar%"</li>
-                    <li data-placeholder="char_avatar" class="sd_comfy_workflow_editor_not_found">"%char_avatar%"</li>
-                    <li data-placeholder="reference_image" class="sd_comfy_workflow_editor_not_found" title="Best-fitting image from the Reference Image Library, selected by the image-prompt LLM">"%reference_image%"</li>
-                    <li><hr></li>
-                    <li data-placeholder="seed" class="sd_comfy_workflow_editor_not_found">
-                        "%seed%"
-                        <a href="javascript:;" class="notes-link"><span class="note-link-span" title="Will generate a new random seed in SillyTavern that is then used in the ComfyUI workflow.">?</span></a>
-                    </li>
-                </ul>
-                <div>Custom</div>
-                <div class="sd_comfy_workflow_editor_placeholder_actions">
-                    <span id="sd_comfy_workflow_editor_placeholder_add" title="Add custom placeholder">+</span>
-                </div>
-                <ul class="sd_comfy_workflow_editor_placeholder_list" id="sd_comfy_workflow_editor_placeholder_list_custom">
-                </ul>
-            </div>
-        </div>
-    </div>
-</div>

public/scripts/extensions/stable-diffusion/dropdown.html+0 -12 Viewed

-<div id="sd_dropdown">
-    <ul class="list-group">
-    <span data-i18n="Send me a picture of:">Send me a picture of:</span>
-        <li class="list-group-item" id="sd_you" data-value="you" data-i18n="sd_Yourself">Yourself</li>
-        <li class="list-group-item" id="sd_face" data-value="face" data-i18n="sd_Your_Face">Your Face</li>
-        <li class="list-group-item" id="sd_me" data-value="me" data-i18n="sd_Me">Me</li>
-        <li class="list-group-item" id="sd_world" data-value="world" data-i18n="sd_The_Whole_Story">The Whole Story</li>
-        <li class="list-group-item" id="sd_last" data-value="last" data-i18n="sd_The_Last_Message">The Last Message</li>
-        <li class="list-group-item" id="sd_raw_last" data-value="raw_last" data-i18n="sd_Raw_Last_Message">Raw Last Message</li>
-        <li class="list-group-item" id="sd_background" data-value="background" data-i18n="sd_Background">Background</li>
-    </ul>
-</div>

public/scripts/extensions/stable-diffusion/index.js+0 -6642 Viewed

-import { Popper } from '../../../lib.js';
-import {
-    animation_duration,
-    appendMediaToMessage,
-    event_types,
-    eventSource,
-    formatCharacterAvatar,
-    generateQuietPrompt,
-    getCharacterAvatar,
-    getCurrentChatId,
-    getRequestHeaders,
-    getUserAvatar,
-    online_status,
-    saveSettingsDebounced,
-    substituteParams,
-    substituteParamsExtended,
-    systemUserName,
-    this_chid,
-    user_avatar,
-} from '../../../script.js';
-import {
-    doExtrasFetch,
-    extension_settings,
-    getApiUrl,
-    getContext,
-    modules,
-    renderExtensionTemplateAsync,
-    writeExtensionField,
-} from '../../extensions.js';
-import { selected_group } from '../../group-chats.js';
-import {
-    clamp,
-    debounce,
-    deepMerge,
-    delay,
-    getBase64Async,
-    getCharaFilename,
-    initScrollHeight,
-    isFalseBoolean,
-    isTrueBoolean,
-    resetScrollHeight,
-    saveBase64AsFile,
-    stringFormat,
-    waitUntilCondition,
-} from '../../utils.js';
-import { getMessageTimeStamp, humanizedDateTime } from '../../RossAscends-mods.js';
-import { SECRET_KEYS, secret_state } from '../../secrets.js';
-import { getNovelAnlas, getNovelUnlimitedImageGeneration, loadNovelSubscriptionData } from '../../nai-settings.js';
-import { ConnectionManagerRequestService, getMultimodalCaption } from '../shared.js';
-import { SlashCommandParser } from '../../slash-commands/SlashCommandParser.js';
-import { SlashCommand } from '../../slash-commands/SlashCommand.js';
-import {
-    ARGUMENT_TYPE,
-    SlashCommandArgument,
-    SlashCommandNamedArgument,
-} from '../../slash-commands/SlashCommandArgument.js';
-import { debounce_timeout, IMAGE_OVERSWIPE, MEDIA_DISPLAY, MEDIA_SOURCE, MEDIA_TYPE, SCROLL_BEHAVIOR, SWIPE_DIRECTION, VIDEO_EXTENSIONS } from '../../constants.js';
-import { SlashCommandEnumValue } from '../../slash-commands/SlashCommandEnumValue.js';
-import { callGenericPopup, Popup, POPUP_TYPE } from '../../popup.js';
-import { commonEnumProviders } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
-import { ToolManager } from '../../tool-calling.js';
-import { macros, MacroCategory } from '../../macros/macro-system.js';
-import { t, translate } from '../../i18n.js';
-import { oai_settings } from '../../openai.js';
-import { power_user } from '/scripts/power-user.js';
-import { MacrosParser } from '/scripts/macros.js';
-import { ActionLoaderHandle, loader } from '/scripts/action-loader.js';
-export { MODULE_NAME };
-const MODULE_NAME = 'sd';
-// This is a 1x1 transparent PNG
-const PNG_PIXEL = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=';
-const sources = {
-    extras: 'extras',
-    horde: 'horde',
-    auto: 'auto',
-    sdcpp: 'sdcpp',
-    novel: 'novel',
-    vlad: 'vlad',
-    openai: 'openai',
-    aimlapi: 'aimlapi',
-    comfy: 'comfy',
-    togetherai: 'togetherai',
-    drawthings: 'drawthings',
-    pollinations: 'pollinations',
-    stability: 'stability',
-    huggingface: 'huggingface',
-    chutes: 'chutes',
-    electronhub: 'electronhub',
-    nanogpt: 'nanogpt',
-    bfl: 'bfl',
-    falai: 'falai',
-    xai: 'xai',
-    google: 'google',
-    zai: 'zai',
-    openrouter: 'openrouter',
-    workersai: 'workersai',
-};
-const comfyTypes = {
-    standard: 'standard',
-    runpod_serverless: 'runpod_serverless',
-};
-const initiators = {
-    command: 'command',
-    action: 'action',
-    interactive: 'interactive',
-    wand: 'wand',
-    swipe: 'swipe',
-    tool: 'tool',
-};
-const generationMode = {
-    TOOL: -2,
-    MESSAGE: -1,
-    CHARACTER: 0,
-    USER: 1,
-    SCENARIO: 2,
-    RAW_LAST: 3,
-    NOW: 4,
-    FACE: 5,
-    FREE: 6,
-    BACKGROUND: 7,
-    CHARACTER_MULTIMODAL: 8,
-    USER_MULTIMODAL: 9,
-    FACE_MULTIMODAL: 10,
-    FREE_EXTENDED: 11,
-    CUSTOM: 12,
-};
-const multimodalMap = {
-    [generationMode.CHARACTER]: generationMode.CHARACTER_MULTIMODAL,
-    [generationMode.USER]: generationMode.USER_MULTIMODAL,
-    [generationMode.FACE]: generationMode.FACE_MULTIMODAL,
-};
-const modeLabels = {
-    [generationMode.TOOL]: 'Function Tool Prompt Description',
-    [generationMode.MESSAGE]: 'Chat Message Template',
-    [generationMode.CHARACTER]: 'Character ("Yourself")',
-    [generationMode.FACE]: 'Portrait ("Your Face")',
-    [generationMode.USER]: 'User ("Me")',
-    [generationMode.SCENARIO]: 'Scenario ("The Whole Story")',
-    [generationMode.NOW]: 'Last Message',
-    [generationMode.RAW_LAST]: 'Raw Last Message',
-    [generationMode.BACKGROUND]: 'Background',
-    [generationMode.CHARACTER_MULTIMODAL]: 'Character (Multimodal Mode)',
-    [generationMode.FACE_MULTIMODAL]: 'Portrait (Multimodal Mode)',
-    [generationMode.USER_MULTIMODAL]: 'User (Multimodal Mode)',
-    [generationMode.FREE_EXTENDED]: 'Free Mode (LLM-Extended)',
-    [generationMode.CUSTOM]: 'Custom',
-};
-const triggerWords = {
-    [generationMode.CHARACTER]: ['you'],
-    [generationMode.USER]: ['me'],
-    [generationMode.SCENARIO]: ['scene'],
-    [generationMode.RAW_LAST]: ['raw_last'],
-    [generationMode.NOW]: ['last'],
-    [generationMode.FACE]: ['face'],
-    [generationMode.BACKGROUND]: ['background'],
-};
-const messageTrigger = {
-    activationRegex: /\b(send|mail|imagine|generate|make|create|draw|paint|render|show)\b.{0,10}\b(pic|picture|image|drawing|painting|photo|photograph)\b(?:\s+of)?(?:\s+(?:a|an|the|this|that|those|your)?\s+)?(.+)/i,
-    specialCases: {
-        [generationMode.CHARACTER]: ['you', 'yourself'],
-        [generationMode.USER]: ['me', 'myself'],
-        [generationMode.SCENARIO]: ['story', 'scenario', 'whole story'],
-        [generationMode.NOW]: ['last message'],
-        [generationMode.FACE]: ['face', 'portrait', 'selfie'],
-        [generationMode.BACKGROUND]: ['background', 'scene background', 'scene', 'scenery', 'surroundings', 'environment'],
-    },
-};
-const promptTemplates = {
-    // Not really a prompt template, rather an outcome message template and function tool prompt
-    [generationMode.MESSAGE]: '[{{char}} sends a picture that contains: {{prompt}}].',
-    [generationMode.TOOL]: [
-        'The text prompt used to generate the image.',
-        'Must represent an exhaustive description of the desired image that will allow an artist or a photographer to perfectly recreate it.',
-    ].join(' '),
-    [generationMode.CHARACTER]: 'In the next response I want you to provide only a detailed comma-delimited list of keywords and phrases which describe {{char}}. The list must include all of the following items in this order: name, species and race, gender, age, clothing, occupation, physical features and appearances. Do not include descriptions of non-visual qualities such as personality, movements, scents, mental traits, or anything which could not be seen in a still photograph. Do not write in full sentences. Prefix your description with the phrase \'full body portrait,\'',
-    //face-specific prompt
-    [generationMode.FACE]: 'In the next response I want you to provide only a detailed comma-delimited list of keywords and phrases which describe {{char}}. The list must include all of the following items in this order: name, species and race, gender, age, facial features and expressions, occupation, hair and hair accessories (if any), what they are wearing on their upper body (if anything). Do not describe anything below their neck. Do not include descriptions of non-visual qualities such as personality, movements, scents, mental traits, or anything which could not be seen in a still photograph. Do not write in full sentences. Prefix your description with the phrase \'close up facial portrait,\'',
-    //prompt for only the last message
-    [generationMode.USER]: 'Ignore previous instructions and provide a detailed description of {{user}}\'s physical appearance from the perspective of {{char}} in the form of a comma-delimited list of keywords and phrases. The list must include all of the following items in this order: name, species and race, gender, age, clothing, occupation, physical features and appearances. Do not include descriptions of non-visual qualities such as personality, movements, scents, mental traits, or anything which could not be seen in a still photograph. Do not write in full sentences. Prefix your description with the phrase \'full body portrait,\'. Ignore the rest of the story when crafting this description. Do not reply as {{char}} when writing this description, and do not attempt to continue the story.',
-    [generationMode.SCENARIO]: 'Ignore previous instructions and provide a detailed description for all of the following: a brief recap of recent events in the story, {{char}}\'s appearance, and {{char}}\'s surroundings. Do not reply as {{char}} while writing this description.',
-    [generationMode.NOW]: `Ignore previous instructions. Your next response must be formatted as a single comma-delimited list of concise keywords.  The list will describe of the visual details included in the last chat message.
-    Only mention characters by using pronouns ('he','his','she','her','it','its') or neutral nouns ('male', 'the man', 'female', 'the woman').
-    Ignore non-visible things such as feelings, personality traits, thoughts, and spoken dialog.
-    Add keywords in this precise order:
-    a keyword to describe the location of the scene,
-    a keyword to mention how many characters of each gender or type are present in the scene (minimum of two characters:
-    {{user}} and {{char}}, example: '2 men ' or '1 man 1 woman ', '1 man 3 robots'),
-    keywords to describe the relative physical positioning of the characters to each other (if a commonly known term for the positioning is known use it instead of describing the positioning in detail) + 'POV',
-    a single keyword or phrase to describe the primary act taking place in the last chat message,
-    keywords to describe {{char}}'s physical appearance and facial expression,
-    keywords to describe {{char}}'s actions,
-    keywords to describe {{user}}'s physical appearance and actions.
-    If character actions involve direct physical interaction with another character, mention specifically which body parts interacting and how.
-    A correctly formatted example response would be:
-    '(location),(character list by gender),(primary action), (relative character position) POV, (character 1's description and actions), (character 2's description and actions)'`,
-    [generationMode.RAW_LAST]: 'Ignore previous instructions and provide ONLY the last chat message string back to me verbatim. Do not write anything after the string. Do not reply as {{char}} when writing this description, and do not attempt to continue the story.',
-    [generationMode.BACKGROUND]: 'Ignore previous instructions and provide a detailed description of {{char}}\'s surroundings in the form of a comma-delimited list of keywords and phrases. The list must include all of the following items in this order: location, time of day, weather, lighting, and any other relevant details. Do not include descriptions of characters and non-visual qualities such as names, personality, movements, scents, mental traits, or anything which could not be seen in a still photograph. Do not write in full sentences. Prefix your description with the phrase \'background,\'. Ignore the rest of the story when crafting this description. Do not reply as {{char}} when writing this description, and do not attempt to continue the story.',
-    [generationMode.FACE_MULTIMODAL]: 'Provide an exhaustive comma-separated list of tags describing the appearance of the character on this image in great detail. Start with "close-up portrait".',
-    [generationMode.CHARACTER_MULTIMODAL]: 'Provide an exhaustive comma-separated list of tags describing the appearance of the character on this image in great detail. Start with "full body portrait".',
-    [generationMode.USER_MULTIMODAL]: 'Provide an exhaustive comma-separated list of tags describing the appearance of the character on this image in great detail. Start with "full body portrait".',
-    [generationMode.FREE_EXTENDED]: 'Ignore previous instructions and provide an exhaustive comma-separated list of tags describing the appearance of "{0}" in great detail. Start with {{charPrefix}} (sic) if the subject is associated with {{char}}.',
-};
-const defaultPrefix = 'best quality, absurdres, aesthetic,';
-const defaultNegative = 'lowres, bad anatomy, bad hands, text, error, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry';
-const defaultStyles = [
-    {
-        name: 'Default',
-        negative: defaultNegative,
-        prefix: defaultPrefix,
-    },
-];
-const placeholderVae = 'Automatic';
-const defaultSettings = {
-    source: sources.extras,
-    // CFG Scale
-    scale_min: 1,
-    scale_max: 30,
-    scale_step: 0.1,
-    scale: 7,
-    // Sampler steps
-    steps_min: 1,
-    steps_max: 150,
-    steps_step: 1,
-    steps: 20,
-    // Scheduler
-    scheduler: 'normal',
-    // Image dimensions (Width & Height)
-    dimension_min: 64,
-    dimension_max: 2048,
-    dimension_step: 64,
-    width: 512,
-    height: 512,
-    prompt_prefix: defaultPrefix,
-    negative_prompt: defaultNegative,
-    sampler: 'DDIM',
-    model: '',
-    vae: '',
-    seed: -1,
-    // Automatic1111/Horde exclusives
-    restore_faces: false,
-    enable_hr: false,
-    adetailer_face: false,
-    // Horde settings
-    horde: false,
-    horde_nsfw: false,
-    horde_karras: true,
-    horde_sanitize: true,
-    // Refine mode
-    refine_mode: false,
-    interactive_mode: false,
-    multimodal_captioning: false,
-    snap: false,
-    free_extend: false,
-    function_tool: false,
-    minimal_prompt_processing: false,
-    prompts: promptTemplates,
-    // AUTOMATIC1111 settings
-    auto_url: 'http://localhost:7860',
-    auto_auth: '',
-    // stable-diffusion.cpp settings
-    sdcpp_url: 'http://127.0.0.1:1234',
-    vlad_url: 'http://localhost:7860',
-    vlad_auth: '',
-    drawthings_url: 'http://localhost:7860',
-    drawthings_auth: '',
-    hr_upscaler: 'Latent',
-    hr_scale: 1.0,
-    hr_scale_min: 1.0,
-    hr_scale_max: 4.0,
-    hr_scale_step: 0.1,
-    denoising_strength: 0.7,
-    denoising_strength_min: 0.0,
-    denoising_strength_max: 1.0,
-    denoising_strength_step: 0.01,
-    hr_second_pass_steps: 0,
-    hr_second_pass_steps_min: 0,
-    hr_second_pass_steps_max: 150,
-    hr_second_pass_steps_step: 1,
-    // CLIP skip
-    clip_skip_min: 1,
-    clip_skip_max: 12,
-    clip_skip_step: 1,
-    clip_skip: 1,
-    // NovelAI settings
-    novel_anlas_guard: false,
-    novel_sm: false,
-    novel_sm_dyn: false,
-    novel_decrisper: false,
-    novel_variety_boost: false,
-    // OpenAI settings
-    openai_style: 'vivid',
-    openai_quality: 'standard',
-    openai_quality_gpt: 'auto',
-    openai_duration: '8',
-    style: 'Default',
-    styles: defaultStyles,
-    // ComyUI settings
-    comfy_type: 'standard',
-    comfy_url: 'http://127.0.0.1:8188',
-    comfy_workflow: 'Default_Comfy_Workflow.json',
-    comfy_runpod_url: '',
-    // Pollinations settings
-    pollinations_enhance: false,
-    // Visibility toggles
-    wand_visible: false,
-    command_visible: false,
-    interactive_visible: false,
-    tool_visible: false,
-    // Stability AI settings
-    stability_style_preset: 'anime',
-    // BFL API settings
-    bfl_upsampling: false,
-    // Google settings
-    google_api: 'makersuite',
-    google_enhance: true,
-    google_duration: 6,
-    // Settings presets & auto-fallback ({ name, preset } entries, tried in order)
-    settings_preset_chain: [],
-    settings_fallback_enabled: false,
-    // Reference image library ({ tag, description, path } entries)
-    ref_images_enabled: false,
-    ref_images: [],
-    // 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: '',
-    lora_strength: 1.0,
-    lora_strength_min: 0.0,
-    lora_strength_max: 2.0,
-    lora_strength_step: 0.01,
-    // 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: '',
-    // User-defined custom wand dropdown entries ({ id, title, prompt })
-    custom_entries: [],
-};
-/**
- * Keys that are NOT part of a settings preset snapshot.
- * A preset captures backend/connection params (source, model, sampler, dimensions, etc.)
- * but not the prompt library, styles, custom entries, or UI prefs.
- * @type {string[]}
- */
-const PRESET_EXCLUDE_KEYS = [
-    'settings_preset_chain',
-    'settings_fallback_enabled',
-    // The reference image library is global, not a per-backend setting.
-    'ref_images_enabled',
-    'ref_images',
-    'runpod_lazy_url',
-    'runpod_models',
-    // The image-prompt LLM profile is independent of the image backend, so it must
-    // never be captured/swapped by image-generation presets or the fallback retry.
-    'prompt_generation_profile',
-    'prompts',
-    'character_prompts',
-    'character_negative_prompts',
-    'styles',
-    'custom_entries',
-    'interactive_visible',
-    'wand_visible',
-    'command_visible',
-    'tool_visible',
-    'expand',
-];
-/**
- * Creates a deep clone snapshot of the settings keys that belong to a preset.
- * @returns {object} Snapshot of the included settings keys.
- */
-function snapshotSdSettings() {
-    const snapshot = {};
-    for (const key of Object.keys(extension_settings.sd)) {
-        if (PRESET_EXCLUDE_KEYS.includes(key)) {
-            continue;
-        }
-        snapshot[key] = structuredClone(extension_settings.sd[key]);
-    }
-    return snapshot;
-}
-/**
- * Applies a settings snapshot to the live settings object (in-memory only; does NOT touch the DOM).
- * @param {object} snapshot Snapshot previously created by snapshotSdSettings().
- */
-function applySdSettingsSnapshot(snapshot) {
-    if (!snapshot || typeof snapshot !== 'object') {
-        return;
-    }
-    for (const key of Object.keys(snapshot)) {
-        // Skip excluded keys so older presets that were saved before a key was
-        // excluded (e.g. prompt_generation_profile) can't clobber it on load.
-        if (PRESET_EXCLUDE_KEYS.includes(key)) {
-            continue;
-        }
-        extension_settings.sd[key] = structuredClone(snapshot[key]);
-    }
-}
-/**
- * Checks whether a preset is configured (a non-null object with at least one key).
- * @param {object} preset Preset to check.
- * @returns {boolean} True if the preset is configured.
- */
-function isPresetConfigured(preset) {
-    return !!preset && typeof preset === 'object' && Object.keys(preset).length > 0;
-}
-/**
- * Returns the fallback chain entries that hold a usable preset snapshot, in order.
- * @returns {{name: string, preset: object}[]} Ordered list of configured chain entries.
- */
-function getConfiguredPresetChain() {
-    const chain = Array.isArray(extension_settings.sd.settings_preset_chain) ? extension_settings.sd.settings_preset_chain : [];
-    return chain.filter(entry => entry && isPresetConfigured(entry.preset));
-}
-/**
- * How long to wait for a locally-hosted backend's status endpoint before treating
- * the server as down and moving on to the next entry in the fallback chain.
- */
-const SOURCE_PROBE_TIMEOUT_MS = 1500;
-/**
- * Quickly checks whether the currently configured source is up. Only locally-hosted
- * backends with a status endpoint are probed (ComfyUI, A1111, SD.Next, DrawThings,
- * stable-diffusion.cpp); sources without a probe are assumed reachable.
- * @returns {Promise<boolean>} False when the backend has a probe and it failed.
- */
-async function isCurrentSourceReachable() {
-    /**
-     * @param {string} endpoint ST server ping route for the backend.
-     * @param {object} body Request body identifying the backend server.
-     * @returns {Promise<boolean>} Whether the ping succeeded within the timeout.
-     */
-    const probe = async (endpoint, body) => {
-        try {
-            const result = await fetch(endpoint, {
-                method: 'POST',
-                headers: getRequestHeaders(),
-                signal: AbortSignal.timeout(SOURCE_PROBE_TIMEOUT_MS),
-                body: JSON.stringify(body),
-            });
-            return result.ok;
-        } catch {
-            return false;
-        }
-    };
-    switch (extension_settings.sd.source) {
-        case sources.comfy:
-            if (extension_settings.sd.comfy_type !== comfyTypes.standard) {
-                return true;
-            }
-            if (isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
-                return isRunpodReady(SOURCE_PROBE_TIMEOUT_MS);
-            }
-            return probe('/api/sd/comfy/ping', { url: extension_settings.sd.comfy_url });
-        case sources.auto:
-        case sources.vlad:
-        case sources.drawthings:
-            return probe(extension_settings.sd.source === sources.drawthings ? '/api/sd/drawthings/ping' : '/api/sd/ping', getSdRequestBody());
-        case sources.sdcpp:
-            return probe('/api/sd/sdcpp/ping', { url: extension_settings.sd.sdcpp_url });
-        default:
-            return true;
-    }
-}
-/**
- * Refreshes all settings UI controls to reflect the current extension_settings.sd values.
- * Used after loading a settings preset.
- * @returns {Promise<void>}
- */
-async function refreshSettingsUi() {
-    // loadSettings() appends to #sd_style without clearing it, so empty it first.
-    $('#sd_style').empty();
-    await loadSettings();
-}
-const writePromptFieldsDebounced = debounce(writePromptFields, debounce_timeout.relaxed);
-const isVideo = (/** @type {string} */ format) => VIDEO_EXTENSIONS.includes(String(format || '').trim().toLowerCase());
-/**
- * Generate interceptor for interactive mode triggers.
- * @param {any[]} chat Chat messages
- * @param {number} _ Context size (unused)
- * @param {function(boolean): void} abort Abort generation function
- * @param {string} type Type of the generation
- */
-function processTriggers(chat, _, abort, type) {
-    if (type === 'quiet') {
-        return;
-    }
-    if (extension_settings.sd.function_tool && ToolManager.isToolCallingSupported()) {
-        return;
-    }
-    if (!extension_settings.sd.interactive_mode) {
-        return;
-    }
-    const lastMessage = chat[chat.length - 1];
-    if (!lastMessage) {
-        return;
-    }
-    const message = lastMessage.mes;
-    const isUser = lastMessage.is_user;
-    if (!message || !isUser) {
-        return;
-    }
-    const messageLower = message.toLowerCase();
-    try {
-        const activationRegex = new RegExp(messageTrigger.activationRegex, 'i');
-        const activationMatch = messageLower.match(activationRegex);
-        if (!activationMatch) {
-            return;
-        }
-        let subject = activationMatch[3].trim();
-        if (!subject) {
-            return;
-        }
-        console.log(`SD: Triggered by "${message}", detected subject: "${subject}"`);
-        outer: for (const [specialMode, triggers] of Object.entries(messageTrigger.specialCases)) {
-            for (const trigger of triggers) {
-                if (subject === trigger) {
-                    subject = triggerWords[specialMode][0];
-                    console.log(`SD: Detected special case "${trigger}", switching to mode ${specialMode}`);
-                    break outer;
-                }
-            }
-        }
-        abort(true);
-        setTimeout(() => generatePicture(initiators.interactive, {}, subject, message), 1);
-    } catch {
-        console.log('SD: Failed to process triggers.');
-    }
-}
-globalThis.SD_ProcessTriggers = processTriggers;
-function getSdRequestBody() {
-    switch (extension_settings.sd.source) {
-        case sources.vlad:
-            return { url: extension_settings.sd.vlad_url, auth: extension_settings.sd.vlad_auth };
-        case sources.auto:
-            return { url: extension_settings.sd.auto_url, auth: extension_settings.sd.auto_auth };
-        case sources.drawthings:
-            return { url: extension_settings.sd.drawthings_url, auth: extension_settings.sd.drawthings_auth };
-        default:
-            throw new Error('Invalid SD source.');
-    }
-}
-function toggleSourceControls() {
-    $('.sd_settings [data-sd-source]').each(function () {
-        const source = $(this).data('sd-source').split(',');
-        $(this).toggle(source.includes(extension_settings.sd.source));
-    });
-    $('.sd_settings [data-sd-comfy-type]').each(function () {
-        const source = $(this).data('sd-comfy-type').split(',');
-        $(this).toggle(source.includes(extension_settings.sd.comfy_type));
-    });
-}
-let promptGenerationProfileDropdownInitialized = false;
-// Warn at most once per session if a prompt-gen profile is selected but cannot be
-// applied because there is no active connection profile to restore afterward.
-let promptProfileWarnedNoBaseProfile = false;
-/**
- * Populates the dedicated prompt-generation connection profile dropdown.
- * Only initializes once to avoid attaching duplicate Connection Manager event listeners
- * when loadSettings() is called again (e.g. after loading a settings preset).
- */
-function initPromptGenerationProfileDropdown() {
-    if (promptGenerationProfileDropdownInitialized) {
-        return;
-    }
-    try {
-        ConnectionManagerRequestService.handleDropdown(
-            '#sd_prompt_generation_profile',
-            extension_settings.sd.prompt_generation_profile,
-            (profile) => {
-                extension_settings.sd.prompt_generation_profile = profile?.id ?? '';
-                saveSettingsDebounced();
-            },
-        );
-        promptGenerationProfileDropdownInitialized = true;
-    } catch (error) {
-        // Connection Manager may be unavailable/disabled; leave the dropdown empty in that case.
-        console.warn('SD: could not populate prompt-generation profile dropdown', error);
-    }
-}
-async function loadSettings() {
-    // Initialize settings
-    if (Object.keys(extension_settings.sd).length === 0) {
-        Object.assign(extension_settings.sd, defaultSettings);
-    }
-    // Insert missing settings
-    for (const [key, value] of Object.entries(defaultSettings)) {
-        if (extension_settings.sd[key] === undefined) {
-            extension_settings.sd[key] = value;
-        }
-    }
-    if (extension_settings.sd.prompts === undefined) {
-        extension_settings.sd.prompts = promptTemplates;
-    }
-    // Insert missing templates
-    for (const [key, value] of Object.entries(promptTemplates)) {
-        if (extension_settings.sd.prompts[key] === undefined) {
-            extension_settings.sd.prompts[key] = value;
-        }
-    }
-    if (extension_settings.sd.character_prompts === undefined) {
-        extension_settings.sd.character_prompts = {};
-    }
-    if (extension_settings.sd.character_negative_prompts === undefined) {
-        extension_settings.sd.character_negative_prompts = {};
-    }
-    if (!Array.isArray(extension_settings.sd.styles)) {
-        extension_settings.sd.styles = defaultStyles;
-    }
-    // Settings presets & auto-fallback
-    if (!Array.isArray(extension_settings.sd.settings_preset_chain)) {
-        // Migrate the old two-slot primary/secondary presets into a chain.
-        const chain = [];
-        if (isPresetConfigured(extension_settings.sd.settings_preset_primary)) {
-            chain.push({ name: 'Primary', preset: extension_settings.sd.settings_preset_primary });
-        }
-        if (isPresetConfigured(extension_settings.sd.settings_preset_secondary)) {
-            chain.push({ name: 'Secondary', preset: extension_settings.sd.settings_preset_secondary });
-        }
-        extension_settings.sd.settings_preset_chain = chain;
-        delete extension_settings.sd.settings_preset_primary;
-        delete extension_settings.sd.settings_preset_secondary;
-    }
-    if (extension_settings.sd.settings_fallback_enabled === undefined) {
-        extension_settings.sd.settings_fallback_enabled = false;
-    }
-    // Reference image library
-    if (extension_settings.sd.ref_images_enabled === undefined) {
-        extension_settings.sd.ref_images_enabled = false;
-    }
-    if (!Array.isArray(extension_settings.sd.ref_images)) {
-        extension_settings.sd.ref_images = [];
-    }
-    if (!Array.isArray(extension_settings.sd.runpod_models)) {
-        extension_settings.sd.runpod_models = [];
-    }
-    if (extension_settings.sd.lora === undefined) {
-        extension_settings.sd.lora = '';
-    }
-    if (typeof extension_settings.sd.lora_strength !== 'number') {
-        extension_settings.sd.lora_strength = 1.0;
-    }
-    // The flux workflows moved from a hardcoded flux2 VAE to %vae%; a leftover
-    // flux1 selection ('ae.safetensors') would fail pod-side validation.
-    const migrateVae = (config) => {
-        if (config && config.vae === 'ae.safetensors') {
-            config.vae = 'flux2-vae.safetensors';
-        }
-    };
-    migrateVae(extension_settings.sd);
-    (extension_settings.sd.settings_preset_chain ?? []).forEach(entry => migrateVae(entry?.preset));
-    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 = [];
-    }
-    // Preserve an original seed if exists
-    if (extension_settings.sd.original_seed >= 0) {
-        extension_settings.sd.seed = extension_settings.sd.original_seed;
-        delete extension_settings.sd.original_seed;
-    }
-    $('#sd_source').val(extension_settings.sd.source);
-    $('#sd_scale').val(extension_settings.sd.scale).trigger('input');
-    $('#sd_steps').val(extension_settings.sd.steps).trigger('input');
-    $('#sd_prompt_prefix').val(extension_settings.sd.prompt_prefix).trigger('input');
-    $('#sd_negative_prompt').val(extension_settings.sd.negative_prompt).trigger('input');
-    $('#sd_width').val(extension_settings.sd.width).trigger('input');
-    $('#sd_height').val(extension_settings.sd.height).trigger('input');
-    $('#sd_hr_scale').val(extension_settings.sd.hr_scale).trigger('input');
-    $('#sd_denoising_strength').val(extension_settings.sd.denoising_strength).trigger('input');
-    $('#sd_lora_strength').val(extension_settings.sd.lora_strength ?? 1.0).trigger('input');
-    $('#sd_hr_second_pass_steps').val(extension_settings.sd.hr_second_pass_steps).trigger('input');
-    $('#sd_novel_anlas_guard').prop('checked', extension_settings.sd.novel_anlas_guard);
-    $('#sd_novel_sm').prop('checked', extension_settings.sd.novel_sm);
-    $('#sd_novel_sm_dyn').prop('checked', extension_settings.sd.novel_sm_dyn);
-    $('#sd_novel_sm_dyn').prop('disabled', !extension_settings.sd.novel_sm);
-    $('#sd_novel_decrisper').prop('checked', extension_settings.sd.novel_decrisper);
-    $('#sd_novel_variety_boost').prop('checked', extension_settings.sd.novel_variety_boost);
-    $('#sd_pollinations_enhance').prop('checked', extension_settings.sd.pollinations_enhance);
-    $('#sd_horde').prop('checked', extension_settings.sd.horde);
-    $('#sd_horde_nsfw').prop('checked', extension_settings.sd.horde_nsfw);
-    $('#sd_horde_karras').prop('checked', extension_settings.sd.horde_karras);
-    $('#sd_horde_sanitize').prop('checked', extension_settings.sd.horde_sanitize);
-    $('#sd_restore_faces').prop('checked', extension_settings.sd.restore_faces);
-    $('#sd_enable_hr').prop('checked', extension_settings.sd.enable_hr);
-    $('#sd_adetailer_face').prop('checked', extension_settings.sd.adetailer_face);
-    $('#sd_refine_mode').prop('checked', extension_settings.sd.refine_mode);
-    $('#sd_multimodal_captioning').prop('checked', extension_settings.sd.multimodal_captioning);
-    $('#sd_auto_url').val(extension_settings.sd.auto_url);
-    $('#sd_auto_auth').val(extension_settings.sd.auto_auth);
-    $('#sd_sdcpp_url').val(extension_settings.sd.sdcpp_url);
-    $('#sd_vlad_url').val(extension_settings.sd.vlad_url);
-    $('#sd_vlad_auth').val(extension_settings.sd.vlad_auth);
-    $('#sd_drawthings_url').val(extension_settings.sd.drawthings_url);
-    $('#sd_drawthings_auth').val(extension_settings.sd.drawthings_auth);
-    $('#sd_interactive_mode').prop('checked', extension_settings.sd.interactive_mode);
-    $('#sd_openai_style').val(extension_settings.sd.openai_style);
-    $('#sd_openai_quality').val(extension_settings.sd.openai_quality);
-    $('#sd_openai_quality_gpt').val(extension_settings.sd.openai_quality_gpt);
-    $('#sd_openai_duration').val(extension_settings.sd.openai_duration);
-    $('#sd_comfy_type').val(extension_settings.sd.comfy_type);
-    $('#sd_comfy_url').val(extension_settings.sd.comfy_url);
-    $('#sd_comfy_prompt').val(extension_settings.sd.comfy_prompt);
-    $('#sd_comfy_runpod_url').val(extension_settings.sd.comfy_runpod_url);
-    $('#sd_snap').prop('checked', extension_settings.sd.snap);
-    $('#sd_minimal_prompt_processing').prop('checked', extension_settings.sd.minimal_prompt_processing);
-    $('#sd_clip_skip').val(extension_settings.sd.clip_skip);
-    $('#sd_clip_skip_value').val(extension_settings.sd.clip_skip);
-    $('#sd_seed').val(extension_settings.sd.seed);
-    $('#sd_free_extend').prop('checked', extension_settings.sd.free_extend);
-    $('#sd_wand_visible').prop('checked', extension_settings.sd.wand_visible);
-    $('#sd_command_visible').prop('checked', extension_settings.sd.command_visible);
-    $('#sd_interactive_visible').prop('checked', extension_settings.sd.interactive_visible);
-    $('#sd_tool_visible').prop('checked', extension_settings.sd.tool_visible);
-    $('#sd_stability_style_preset').val(extension_settings.sd.stability_style_preset);
-    $('#sd_huggingface_model_id').val(extension_settings.sd.huggingface_model_id);
-    $('#sd_function_tool').prop('checked', extension_settings.sd.function_tool);
-    $('#sd_bfl_upsampling').prop('checked', extension_settings.sd.bfl_upsampling);
-    $('#sd_google_api').val(extension_settings.sd.google_api);
-    $('#sd_google_enhance').prop('checked', extension_settings.sd.google_enhance);
-    $('#sd_google_duration').val(extension_settings.sd.google_duration);
-    $('#sd_fallback_enabled').prop('checked', extension_settings.sd.settings_fallback_enabled);
-    $('#sd_ref_images_enabled').prop('checked', extension_settings.sd.ref_images_enabled);
-    $('#sd_runpod_lazy_url').val(extension_settings.sd.runpod_lazy_url ?? '');
-    renderPresetChain();
-    renderRefImages();
-    renderRunpodModels();
-    setupRunpodLoops();
-    for (const style of extension_settings.sd.styles) {
-        const option = document.createElement('option');
-        option.value = style.name;
-        option.text = style.name;
-        option.selected = style.name === extension_settings.sd.style;
-        $('#sd_style').append(option);
-    }
-    const resolutionId = getClosestKnownResolution();
-    $('#sd_resolution').val(resolutionId);
-    initPromptGenerationProfileDropdown();
-    toggleSourceControls();
-    addPromptTemplates();
-    renderCustomEntriesList();
-    renderCustomDropdownEntries();
-    registerFunctionTool();
-    await loadSettingOptions();
-}
-/**
- * Find a closest resolution option match for the current width and height.
- */
-function getClosestKnownResolution() {
-    let resolutionId = null;
-    let minTotalDiff = Infinity;
-    const targetAspect = extension_settings.sd.width / extension_settings.sd.height;
-    const targetResolution = extension_settings.sd.width * extension_settings.sd.height;
-    const diffs = Object.entries(resolutionOptions).map(([id, resolution]) => {
-        const aspectDiff = Math.abs((resolution.width / resolution.height) - targetAspect) / targetAspect;
-        const resolutionDiff = Math.abs(resolution.width * resolution.height - targetResolution) / targetResolution;
-        return { id, totalDiff: aspectDiff + resolutionDiff };
-    });
-    for (const { id, totalDiff } of diffs) {
-        if (totalDiff < minTotalDiff) {
-            minTotalDiff = totalDiff;
-            resolutionId = id;
-        }
-    }
-    return resolutionId;
-}
-async function loadSettingOptions() {
-    return Promise.all([
-        loadSamplers(),
-        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();
-    for (const [name, prompt] of Object.entries(extension_settings.sd.prompts).sort((a, b) => Number(a[0]) - Number(b[0]))) {
-        const label = $('<label></label>')
-            .text(modeLabels[name])
-            .attr('for', `sd_prompt_${name}`)
-            .attr('data-i18n', `sd_prompt_${name}`);
-        const textarea = $('<textarea></textarea>')
-            .addClass('textarea_compact text_pole')
-            .attr('id', `sd_prompt_${name}`)
-            .attr('rows', 3)
-            .val(prompt).on('input', () => {
-                extension_settings.sd.prompts[name] = textarea.val();
-                saveSettingsDebounced();
-            });
-        const button = $('<button></button>')
-            .addClass('menu_button fa-solid fa-undo')
-            .attr('title', 'Restore default')
-            .attr('data-i18n', 'Restore default')
-            .on('click', () => {
-                textarea.val(promptTemplates[name]);
-                extension_settings.sd.prompts[name] = promptTemplates[name];
-                if (String(name) === String(generationMode.TOOL)) {
-                    registerFunctionTool();
-                }
-                saveSettingsDebounced();
-            });
-        const container = $('<div></div>')
-            .addClass('title_restorable')
-            .append(label)
-            .append(button);
-        $('#sd_prompt_templates').append(container);
-        $('#sd_prompt_templates').append(textarea);
-    }
-}
-function onInteractiveModeInput() {
-    extension_settings.sd.interactive_mode = !!$(this).prop('checked');
-    saveSettingsDebounced();
-}
-function onMultimodalCaptioningInput() {
-    extension_settings.sd.multimodal_captioning = !!$(this).prop('checked');
-    saveSettingsDebounced();
-}
-function onSnapInput() {
-    extension_settings.sd.snap = !!$(this).prop('checked');
-    saveSettingsDebounced();
-}
-function onMinimalPromptProcessing() {
-    extension_settings.sd.minimal_prompt_processing = !!$(this).prop('checked');
-    saveSettingsDebounced();
-}
-function onStyleSelect() {
-    const selectedStyle = String($('#sd_style').find(':selected').val());
-    const styleObject = extension_settings.sd.styles.find(x => x.name === selectedStyle);
-    if (!styleObject) {
-        console.warn(`Could not find style object for ${selectedStyle}`);
-        return;
-    }
-    $('#sd_prompt_prefix').val(styleObject.prefix).trigger('input');
-    $('#sd_negative_prompt').val(styleObject.negative).trigger('input');
-    extension_settings.sd.style = selectedStyle;
-    saveSettingsDebounced();
-}
-async function onDeleteStyleClick() {
-    const selectedStyle = String($('#sd_style').find(':selected').val());
-    const styleObject = extension_settings.sd.styles.find(x => x.name === selectedStyle);
-    if (!styleObject) {
-        return;
-    }
-    const confirmed = await callGenericPopup(t`Are you sure you want to delete the style "${selectedStyle}"?`, POPUP_TYPE.CONFIRM, '', { okButton: 'Delete', cancelButton: 'Cancel' });
-    if (!confirmed) {
-        return;
-    }
-    const index = extension_settings.sd.styles.indexOf(styleObject);
-    if (index === -1) {
-        return;
-    }
-    extension_settings.sd.styles.splice(index, 1);
-    $('#sd_style').find(`option[value="${selectedStyle}"]`).remove();
-    if (extension_settings.sd.styles.length > 0) {
-        extension_settings.sd.style = extension_settings.sd.styles[0].name;
-        $('#sd_style').val(extension_settings.sd.style).trigger('change');
-    } else {
-        extension_settings.sd.style = '';
-        $('#sd_prompt_prefix').val('').trigger('input');
-        $('#sd_negative_prompt').val('').trigger('input');
-        $('#sd_style').val('');
-    }
-    saveSettingsDebounced();
-}
-async function onSaveStyleClick() {
-    const selectedStyle = extension_settings.sd.style || '';
-    const userInput = await callGenericPopup(t`Enter style name:`, POPUP_TYPE.INPUT, selectedStyle);
-    if (!userInput) {
-        return;
-    }
-    const name = String(userInput).trim();
-    const prefix = String($('#sd_prompt_prefix').val());
-    const negative = String($('#sd_negative_prompt').val());
-    const existingStyle = extension_settings.sd.styles.find(x => x.name === name);
-    if (existingStyle) {
-        existingStyle.prefix = prefix;
-        existingStyle.negative = negative;
-        $('#sd_style').val(name);
-        saveSettingsDebounced();
-        return;
-    }
-    const styleObject = {
-        name: name,
-        prefix: prefix,
-        negative: negative,
-    };
-    extension_settings.sd.styles.push(styleObject);
-    const option = document.createElement('option');
-    option.value = styleObject.name;
-    option.text = styleObject.name;
-    option.selected = true;
-    $('#sd_style').append(option);
-    $('#sd_style').val(styleObject.name);
-    saveSettingsDebounced();
-}
-async function onRenameStyleClick() {
-    const selectedStyle = extension_settings.sd.style;
-    const styleObject = extension_settings.sd.styles.find(x => x.name === selectedStyle);
-    if (!styleObject) {
-        return;
-    }
-    const newName = await callGenericPopup(t`Enter new style name:`, POPUP_TYPE.INPUT, selectedStyle);
-    if (!newName) {
-        return;
-    }
-    const name = String(newName).trim();
-    if (name === selectedStyle) {
-        return;
-    }
-    const existingStyle = extension_settings.sd.styles.find(x => x.name === name);
-    if (existingStyle) {
-        toastr.error(t`A style with that name already exists`);
-        return;
-    }
-    styleObject.name = name;
-    extension_settings.sd.style = name;
-    $('#sd_style').empty();
-    for (const style of extension_settings.sd.styles) {
-        const option = document.createElement('option');
-        option.value = style.name;
-        option.text = style.name;
-        option.selected = style.name === extension_settings.sd.style;
-        $('#sd_style').append(option);
-    }
-    saveSettingsDebounced();
-}
-/**
- * Rebuilds the provider fallback chain list in the settings UI.
- */
-function renderPresetChain() {
-    const container = $('#sd_preset_chain_list');
-    if (!container.length) {
-        return;
-    }
-    container.empty();
-    const chain = Array.isArray(extension_settings.sd.settings_preset_chain) ? extension_settings.sd.settings_preset_chain : [];
-    if (chain.length === 0) {
-        const empty = $('<small></small>')
-            .attr('data-i18n', 'No presets in the chain yet.')
-            .text('No presets in the chain yet.');
-        container.append(empty);
-        return;
-    }
-    chain.forEach((entry, index) => {
-        const orderEl = $('<div></div>').addClass('sd_preset_chain_order').text(`${index + 1}.`);
-        const sourceHint = String(entry.preset?.source ?? '');
-        const nameInput = $('<input>')
-            .addClass('text_pole flex1')
-            .attr('type', 'text')
-            .attr('title', sourceHint ? `Source: ${sourceHint}` : '')
-            .val(entry.name || '')
-            .on('change', function () {
-                entry.name = String($(this).val() ?? '').trim() || `Preset ${index + 1}`;
-                saveSettingsDebounced();
-            });
-        const makeButton = (icon, title, handler) => $('<div></div>')
-            .addClass(`menu_button menu_button_icon fa-solid ${icon}`)
-            .attr('title', title)
-            .attr('data-i18n', `[title]${title}`)
-            .on('click', handler);
-        const upButton = makeButton('fa-chevron-up', 'Move up', () => {
-            if (index === 0) return;
-            [chain[index - 1], chain[index]] = [chain[index], chain[index - 1]];
-            saveSettingsDebounced();
-            renderPresetChain();
-        });
-        const downButton = makeButton('fa-chevron-down', 'Move down', () => {
-            if (index === chain.length - 1) return;
-            [chain[index + 1], chain[index]] = [chain[index], chain[index + 1]];
-            saveSettingsDebounced();
-            renderPresetChain();
-        });
-        const loadButton = makeButton('fa-file-import', 'Load this preset into the current settings', async () => {
-            applySdSettingsSnapshot(entry.preset);
-            saveSettingsDebounced();
-            await refreshSettingsUi();
-            toastr.success(t`Settings preset loaded.`, t`Image Generation`);
-        });
-        const saveButton = makeButton('fa-floppy-disk', 'Overwrite this preset with the current settings', () => {
-            entry.preset = snapshotSdSettings();
-            saveSettingsDebounced();
-            renderPresetChain();
-            toastr.success(t`Settings preset updated.`, t`Image Generation`);
-        });
-        const deleteButton = makeButton('fa-trash-can', 'Remove from the chain', () => {
-            chain.splice(index, 1);
-            saveSettingsDebounced();
-            renderPresetChain();
-        });
-        const row = $('<div></div>')
-            .addClass('flex-container alignItemsCenter marginTopBot5')
-            .append(orderEl)
-            .append(nameInput)
-            .append(upButton)
-            .append(downButton)
-            .append(loadButton)
-            .append(saveButton)
-            .append(deleteButton);
-        container.append(row);
-    });
-}
-function onPresetChainAddClick() {
-    const nameInput = $('#sd_preset_chain_name');
-    const name = String(nameInput.val() ?? '').trim();
-    const chain = extension_settings.sd.settings_preset_chain;
-    chain.push({ name: name || `Preset ${chain.length + 1}`, preset: snapshotSdSettings() });
-    nameInput.val('');
-    saveSettingsDebounced();
-    renderPresetChain();
-    toastr.success(t`Current settings added to the fallback chain.`, t`Image Generation`);
-}
-function onFallbackEnabledChange() {
-    extension_settings.sd.settings_fallback_enabled = !!$(this).prop('checked');
-    saveSettingsDebounced();
-}
-// #region Reference image library
-/**
- * Matches the reference image placeholder in a raw ComfyUI workflow ("%reference_image%" or "%reference-image%").
- */
-const REFERENCE_IMAGE_PLACEHOLDER = /"%reference[-_]image%"/i;
-/**
- * Reference image chosen for the in-flight generation. Set at prompt-generation time
- * (or lazily by the workflow builder) and read when the ComfyUI workflow is assembled.
- * Deliberately kept across swipe regenerations so a swipe reuses the same reference.
- * @type {{tag: string, description: string, path: string} | null}
- */
-let pendingReferenceImage = null;
-/**
- * Returns library entries that have an uploaded image.
- * @returns {{tag: string, description: string, path: string}[]} Valid reference images.
- */
-function getValidRefImages() {
-    const images = Array.isArray(extension_settings.sd.ref_images) ? extension_settings.sd.ref_images : [];
-    return images.filter(image => image && typeof image.path === 'string' && image.path.length > 0);
-}
-/**
- * Rebuilds the reference image library list in the settings UI.
- */
-function renderRefImages() {
-    const container = $('#sd_ref_images_list');
-    if (!container.length) {
-        return;
-    }
-    container.empty();
-    const images = Array.isArray(extension_settings.sd.ref_images) ? extension_settings.sd.ref_images : [];
-    if (images.length === 0) {
-        const empty = $('<small></small>')
-            .attr('data-i18n', 'No reference images yet.')
-            .text('No reference images yet.');
-        container.append(empty);
-        return;
-    }
-    images.forEach((image, index) => {
-        const thumb = $('<img>')
-            .addClass('sd_ref_image_thumb')
-            .attr('src', image.path)
-            .attr('alt', image.tag || '');
-        const tagInput = $('<input>')
-            .addClass('text_pole')
-            .attr('type', 'text')
-            .attr('placeholder', 'Tag')
-            .attr('data-i18n', '[placeholder]Tag')
-            .val(image.tag || '')
-            .on('change', function () {
-                image.tag = String($(this).val() ?? '').trim();
-                saveSettingsDebounced();
-            });
-        const descriptionInput = $('<input>')
-            .addClass('text_pole flex1')
-            .attr('type', 'text')
-            .attr('placeholder', 'Description (used to pick the best fit)')
-            .attr('data-i18n', '[placeholder]Description (used to pick the best fit)')
-            .val(image.description || '')
-            .on('change', function () {
-                image.description = String($(this).val() ?? '').trim();
-                saveSettingsDebounced();
-            });
-        const deleteButton = $('<div></div>')
-            .addClass('menu_button menu_button_icon fa-solid fa-trash-can')
-            .attr('title', 'Remove reference image')
-            .attr('data-i18n', '[title]Remove reference image')
-            .on('click', () => {
-                images.splice(index, 1);
-                saveSettingsDebounced();
-                renderRefImages();
-            });
-        const row = $('<div></div>')
-            .addClass('flex-container alignItemsCenter marginTopBot5')
-            .append(thumb)
-            .append(tagInput)
-            .append(descriptionInput)
-            .append(deleteButton);
-        container.append(row);
-    });
-}
-function onRefImagesEnabledChange() {
-    extension_settings.sd.ref_images_enabled = !!$(this).prop('checked');
-    saveSettingsDebounced();
-}
-async function onRefImagesFileChange() {
-    const files = Array.from(this.files ?? []);
-    this.value = '';
-    for (const file of files) {
-        try {
-            const dataUrl = await getBase64Async(file);
-            const base64 = String(dataUrl).split(',')[1];
-            const extension = (file.type.split('/')[1] || 'png').replace('jpeg', 'jpg');
-            const baseName = file.name.replace(/\.[^/.]+$/, '');
-            const path = await saveBase64AsFile(base64, 'reference-images', baseName, extension);
-            extension_settings.sd.ref_images.push({ tag: baseName, description: '', path });
-        } catch (error) {
-            console.error('SD: failed to add reference image', error);
-            toastr.error(String(error), t`Image Generation`);
-        }
-    }
-    saveSettingsDebounced();
-    renderRefImages();
-}
-/**
- * Collects the ComfyUI workflow file names that could be used by this generation:
- * the live settings' workflow plus, when the fallback chain is enabled, the workflow
- * of every comfy preset in the chain.
- * @returns {string[]} Unique workflow file names.
- */
-function collectCandidateComfyWorkflows() {
-    const names = new Set();
-    /** @param {object} config A settings-shaped object (live settings or a preset snapshot). */
-    const consider = (config) => {
-        if (config && config.source === sources.comfy && config.comfy_type === comfyTypes.standard && config.comfy_workflow) {
-            names.add(config.comfy_workflow);
-        }
-    };
-    consider(extension_settings.sd);
-    if (extension_settings.sd.settings_fallback_enabled) {
-        for (const entry of getConfiguredPresetChain()) {
-            consider(entry.preset);
-        }
-    }
-    return [...names];
-}
-/**
- * Checks whether any workflow this generation could run contains the reference image placeholder.
- * @returns {Promise<boolean>} True when a candidate workflow uses the placeholder.
- */
-async function anyCandidateWorkflowUsesReferenceImage() {
-    for (const fileName of collectCandidateComfyWorkflows()) {
-        try {
-            const result = await fetch('/api/sd/comfy/workflow', {
-                method: 'POST',
-                headers: getRequestHeaders(),
-                body: JSON.stringify({ file_name: fileName }),
-            });
-            if (!result.ok) {
-                continue;
-            }
-            const workflow = await result.json();
-            if (REFERENCE_IMAGE_PLACEHOLDER.test(String(workflow))) {
-                return true;
-            }
-        } catch (error) {
-            console.warn('SD: could not inspect workflow for reference image placeholder', fileName, error);
-        }
-    }
-    return false;
-}
-/**
- * Returns the reference images to choose from for this generation, or an empty array
- * when the feature is disabled, the library is empty, or no candidate workflow uses
- * the placeholder.
- * @returns {Promise<{tag: string, description: string, path: string}[]>} Selectable reference images.
- */
-async function getEligibleReferenceImages() {
-    if (!extension_settings.sd.ref_images_enabled) {
-        return [];
-    }
-    const images = getValidRefImages();
-    if (images.length === 0) {
-        return [];
-    }
-    if (!(await anyCandidateWorkflowUsesReferenceImage())) {
-        return [];
-    }
-    return images;
-}
-/**
- * Builds the instruction appended to the image-prompt request that makes the LLM
- * also pick a reference image, as a machine-readable JSON line.
- * @param {{tag: string, description: string}[]} candidates Reference images to choose from.
- * @returns {string} Instruction text.
- */
-function buildReferenceSelectionAddendum(candidates) {
-    const list = candidates.map(x => `- "${x.tag}": ${x.description || 'no description'}`).join('\n');
-    return [
-        '',
-        'After the image prompt, append one final line containing exactly this JSON and nothing else:',
-        '{"reference_image": "<tag>"}',
-        'where <tag> is the tag of the reference image whose description best fits the requested scene. Available reference images:',
-        list,
-    ].join('\n');
-}
-/**
- * Finds the library entry whose tag matches the given text.
- * @param {string} text Tag text returned by the LLM.
- * @param {{tag: string}[]} candidates Reference images to match against.
- * @returns {object|null} The matching entry, or null.
- */
-function matchReferenceTag(text, candidates) {
-    const needle = String(text ?? '').trim().toLowerCase();
-    if (!needle) {
-        return null;
-    }
-    const tagged = candidates.filter(x => String(x.tag ?? '').trim().length > 0);
-    return tagged.find(x => x.tag.trim().toLowerCase() === needle)
-        ?? tagged.find(x => needle.includes(x.tag.trim().toLowerCase()))
-        ?? null;
-}
-/**
- * Extracts the {"reference_image": "..."} selection from a combined prompt+selection reply.
- * @param {string} reply Raw LLM reply.
- * @param {{tag: string}[]} candidates Reference images to match against.
- * @returns {{cleaned: string, selected: object|null}} Reply without the JSON line, and the matched entry.
- */
-function extractReferenceSelection(reply, candidates) {
-    const pattern = /\{\s*"?reference_image"?\s*:\s*"([^"]*)"\s*\}/gi;
-    let match;
-    let lastTag = null;
-    while ((match = pattern.exec(reply)) !== null) {
-        lastTag = match[1];
-    }
-    const cleaned = reply.replace(/\{\s*"?reference_image"?\s*:\s*"[^"]*"\s*\}/gi, ' ');
-    return { cleaned, selected: lastTag ? matchReferenceTag(lastTag, candidates) : null };
-}
-/**
- * Asks the image-prompt LLM to pick the best-fitting reference image for a scene
- * in a dedicated (second) request.
- * @param {string} prompt The final image prompt describing the scene.
- * @param {{tag: string, description: string}[]} candidates Reference images to choose from.
- * @returns {Promise<object|null>} The matched entry, or null.
- */
-async function selectReferenceImageWithLlm(prompt, candidates) {
-    const list = candidates.map(x => `- "${x.tag}": ${x.description || 'no description'}`).join('\n');
-    const quietPrompt = [
-        'Pause your roleplay. An image is being generated for the current scene from this prompt:',
-        prompt,
-        '',
-        'Pick the reference image whose description best fits that scene:',
-        list,
-        '',
-        'Reply with ONLY the tag of the chosen reference image and nothing else.',
-    ].join('\n');
-    const profileId = extension_settings.sd.prompt_generation_profile;
-    const reply = profileId
-        ? await withConnectionProfile(profileId, () => generateQuietPrompt({ quietPrompt }))
-        : await generateQuietPrompt({ quietPrompt });
-    return matchReferenceTag(String(reply ?? '').trim(), candidates);
-}
-/**
- * Resolves which reference image the current ComfyUI generation should use.
- * Prefers the selection made together with the image prompt; falls back to a
- * dedicated LLM call, and finally to the first library image.
- * @param {string} prompt The image prompt describing the scene.
- * @returns {Promise<object|null>} The reference image to use, or null when the feature is off/empty.
- */
-async function resolveReferenceImageForGeneration(prompt) {
-    if (!extension_settings.sd.ref_images_enabled) {
-        return null;
-    }
-    const images = getValidRefImages();
-    if (images.length === 0) {
-        return null;
-    }
-    if (pendingReferenceImage && images.some(x => x.path === pendingReferenceImage.path)) {
-        return pendingReferenceImage;
-    }
-    if (images.length === 1) {
-        pendingReferenceImage = images[0];
-        return pendingReferenceImage;
-    }
-    try {
-        pendingReferenceImage = await selectReferenceImageWithLlm(prompt, images) ?? images[0];
-    } catch (error) {
-        console.error('SD: reference image selection failed, using the first library image', error);
-        pendingReferenceImage = images[0];
-    }
-    return pendingReferenceImage;
-}
-/**
- * Loads a reference image and returns it as a raw base64 string (no data URL header).
- * @param {{path: string}} refImage Reference image entry.
- * @returns {Promise<string|null>} Base64 image data, or null on failure.
- */
-async function fetchReferenceImageBase64(refImage) {
-    try {
-        const response = await fetch(refImage.path);
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-        }
-        const blob = await response.blob();
-        const dataUrl = await getBase64Async(blob);
-        return String(dataUrl).split(',')[1] ?? null;
-    } catch (error) {
-        console.error('SD: could not load reference image', refImage.path, error);
-        return null;
-    }
-}
-// #endregion
-// #region RunPod lazy pod
-/** Poll cadence for the pod status indicator (faster while it is starting). */
-const RUNPOD_POLL_IDLE_MS = 30000;
-const RUNPOD_POLL_BUSY_MS = 5000;
-/** Frontend heartbeat cadence. The proxy tolerates browser timer pauses for five minutes. */
-const RUNPOD_HEARTBEAT_MS = 20000;
-let runpodStatusTimer = null;
-let runpodHeartbeatTimer = null;
-let runpodLastPhase = 'red';
-function getRunpodLazyUrl() {
-    return String(extension_settings.sd.runpod_lazy_url ?? '').trim().replace(/\/$/, '');
-}
-/**
- * Reads the lazy proxy status without starting or warming a pod.
- * @param {number} timeout Request timeout in milliseconds.
- * @returns {Promise<object>} Parsed /lazy/status response.
- */
-async function getRunpodStatus(timeout = 8000) {
-    const url = getRunpodLazyUrl();
-    if (!url) {
-        throw new Error('RunPod lazy proxy URL is not configured.');
-    }
-    const result = await fetch(`${url}/lazy/status`, { signal: AbortSignal.timeout(timeout) });
-    if (!result.ok) {
-        throw new Error(`RunPod status returned ${result.status}.`);
-    }
-    return result.json();
-}
-/**
- * Checks whether the lazy proxy already has a ready pod.
- * @param {number} timeout Request timeout in milliseconds.
- * @returns {Promise<boolean>} True only when /lazy/status reports green.
- */
-async function isRunpodReady(timeout = 8000) {
-    try {
-        return (await getRunpodStatus(timeout))?.state === 'green';
-    } catch {
-        return false;
-    }
-}
-/**
- * Updates the status dot + text from a /lazy/status response (or an error).
- * @param {object|null} status Parsed status JSON, or null when unreachable.
- */
-function renderRunpodStatus(status) {
-    const dot = document.getElementById('sd_runpod_dot');
-    const text = document.getElementById('sd_runpod_status_text');
-    if (!dot || !text) {
-        return;
-    }
-    const phase = status?.state ?? 'red';
-    runpodLastPhase = phase;
-    const phaseClass = `sd_runpod_${['red', 'orange', 'green'].includes(phase) ? phase : 'red'}`;
-    for (const el of [dot, document.getElementById('sd_runpod_bar_dot')].filter(Boolean)) {
-        el.classList.remove('sd_runpod_red', 'sd_runpod_orange', 'sd_runpod_green');
-        el.classList.add(phaseClass);
-    }
-    const openLink = document.getElementById('sd_runpod_open');
-    if (openLink) {
-        const showLink = phase === 'green' && status?.url;
-        openLink.style.display = showLink ? '' : 'none';
-        if (showLink) {
-            openLink.dataset.url = status.url;
-        }
-    }
-    if (!status) {
-        text.textContent = 'proxy unreachable';
-    } else if (phase === 'green') {
-        const left = status.idle_seconds_left ? ` (idle stop in ${Math.round(status.idle_seconds_left / 60)}m)` : '';
-        text.textContent = `ready on ${status.gpu ?? 'GPU'}${left}`;
-    } else if (phase === 'orange') {
-        text.textContent = `starting (models: ${status.model || (status.active ?? []).join(' + ') || '?'})…`;
-    } else {
-        text.textContent = 'off';
-    }
-    const barDot = document.getElementById('sd_runpod_bar_dot');
-    if (barDot) {
-        barDot.title = `RunPod pod: ${text.textContent} — click to ${phase === 'red' ? 'warm up' : 'shut down'}`;
-    }
-    return phase;
-}
-/** Adds the clickable pod-status dot to the chat bar (next to other extension icons). */
-function ensureRunpodBarDot() {
-    if (document.getElementById('sd_runpod_bar_dot')) {
-        return;
-    }
-    const anchor = document.getElementById('leftSendForm');
-    if (!anchor) {
-        return;
-    }
-    const dot = document.createElement('div');
-    dot.id = 'sd_runpod_bar_dot';
-    dot.classList.add('sd_runpod_dot', 'sd_runpod_bar_dot', 'sd_runpod_red', 'interactable');
-    dot.title = 'RunPod pod';
-    dot.tabIndex = 0;
-    dot.addEventListener('click', () => runpodControl(runpodLastPhase === 'red' ? 'warmup' : 'shutdown'));
-    anchor.appendChild(dot);
-    dot.style.display = getRunpodLazyUrl() ? '' : 'none';
-}
-let runpodPollFailures = 0;
-async function pollRunpodStatus() {
-    const url = getRunpodLazyUrl();
-    if (!url) {
-        return;
-    }
-    let phase = runpodLastPhase;
-    try {
-        runpodPollFailures = 0;
-        phase = renderRunpodStatus(await getRunpodStatus());
-    } catch {
-        // A single slow/failed poll (e.g. while the proxy is provisioning a pod)
-        // must not flip the dot to red; only sustained unreachability does.
-        runpodPollFailures++;
-        if (runpodPollFailures >= 3) {
-            phase = renderRunpodStatus(null);
-        }
-    }
-    clearTimeout(runpodStatusTimer);
-    runpodStatusTimer = setTimeout(pollRunpodStatus, phase === 'orange' || runpodPollFailures ? RUNPOD_POLL_BUSY_MS : RUNPOD_POLL_IDLE_MS);
-}
-async function runpodControl(action) {
-    const url = getRunpodLazyUrl();
-    if (!url) {
-        return;
-    }
-    try {
-        if (action === 'warmup' && !(await pushRunpodCatalog())) {
-            throw new Error('Could not sync the RunPod model catalog. The pod was not started.');
-        }
-        const result = await fetch(`${url}/lazy/${action}`, { method: 'POST', signal: AbortSignal.timeout(10000) });
-        if (!result.ok) {
-            throw new Error(`RunPod ${action} returned ${result.status}.`);
-        }
-        renderRunpodStatus(await result.json());
-        if (action === 'warmup') {
-            toastr.info(t`Pod warmup requested. Models will pre-download; the dot turns green when ready.`, t`Image Generation`);
-        }
-    } catch (error) {
-        toastr.error(String(error), t`Image Generation`);
-    }
-    clearTimeout(runpodStatusTimer);
-    runpodStatusTimer = setTimeout(pollRunpodStatus, RUNPOD_POLL_BUSY_MS);
-}
-function runpodHeartbeat() {
-    const url = getRunpodLazyUrl();
-    if (!url) {
-        return;
-    }
-    // This only renews the proxy's frontend lease and never starts a pod. The
-    // proxy owns the stable upstream keepalive cadence so browser timer
-    // throttling cannot directly skew it.
-    fetch(`${url}/lazy/ping`, { method: 'POST', signal: AbortSignal.timeout(5000) }).catch(() => { });
-}
-/** (Re)starts the status polling and frontend-heartbeat loops. */
-function setupRunpodLoops() {
-    clearTimeout(runpodStatusTimer);
-    clearInterval(runpodHeartbeatTimer);
-    ensureRunpodBarDot();
-    const barDot = document.getElementById('sd_runpod_bar_dot');
-    if (barDot) {
-        barDot.style.display = getRunpodLazyUrl() ? '' : 'none';
-    }
-    if (!getRunpodLazyUrl()) {
-        renderRunpodStatus(null);
-        return;
-    }
-    pollRunpodStatus();
-    runpodHeartbeat();
-    runpodHeartbeatTimer = setInterval(runpodHeartbeat, RUNPOD_HEARTBEAT_MS);
-}
-function onRunpodLazyUrlInput() {
-    extension_settings.sd.runpod_lazy_url = String($(this).val() ?? '').trim();
-    saveSettingsDebounced();
-    setupRunpodLoops();
-}
-/**
- * Whether a comfy URL points at the runpod-lazy proxy.
- * @param {string} url ComfyUI URL to test.
- * @returns {boolean} True when it equals the configured proxy URL.
- */
-function isRunpodProxyUrl(url) {
-    const lazy = getRunpodLazyUrl();
-    return !!lazy && String(url ?? '').trim().replace(/\/$/, '') === lazy;
-}
-/**
- * Returns the configured RunPod model catalog entries that have a filename.
- * @returns {{name: string, value: string, downloads: string}[]} Catalog entries.
- */
-function getRunpodCatalog() {
-    const models = Array.isArray(extension_settings.sd.runpod_models) ? extension_settings.sd.runpod_models : [];
-    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.
- * @returns {{dest: string, url: string}[]} Parsed file list.
- */
-function parseRunpodFiles(text) {
-    return String(text ?? '').split('\n')
-        .map(line => line.trim())
-        .filter(Boolean)
-        .map(line => {
-            const space = line.indexOf(' ');
-            return space > 0 ? { dest: line.slice(0, space).trim(), url: line.slice(space + 1).trim() } : null;
-        })
-        .filter(x => x && x.dest && x.url);
-}
-/**
- * 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[]} Active catalog values (model and/or lora).
- */
-function getRunpodActiveModels() {
-    let config = null;
-    // Only use live settings when the current source is actually ComfyUI AND
-    // its model is in the catalog. If the user is on Grok/OpenRouter but
-    // comfy_url points at the proxy, the fallback chain's ComfyUI presets are
-    // what matter, not the live source which may not even be image-gen capable.
-    if (extension_settings.sd.source === 'comfy' && isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
-        const known = new Set(getRunpodCatalog().map(m => m.value));
-        if (known.has(extension_settings.sd.model)) {
-            config = extension_settings.sd;
-        }
-    }
-    if (!config) {
-        const chain = Array.isArray(extension_settings.sd.settings_preset_chain) ? extension_settings.sd.settings_preset_chain : [];
-        // Find the first ComfyUI preset in the chain, not just any preset with a matching URL
-        config = chain.find(e => e?.preset?.source === 'comfy' && isRunpodProxyUrl(e?.preset?.comfy_url))?.preset ?? 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.
- * Catalog updates only store configuration; only /lazy/warmup may provision.
- * @returns {Promise<boolean>} Whether the proxy accepted the catalog.
- */
-async function pushRunpodCatalog() {
-    const url = getRunpodLazyUrl();
-    if (!url) {
-        return false;
-    }
-    const models = getRunpodCatalog().map(m => ({
-        name: m.name || m.value,
-        value: m.value,
-        kind: m.kind === 'lora' ? 'lora' : 'model',
-        files: parseRunpodFiles(m.downloads),
-    }));
-    try {
-        const result = await fetch(`${url}/lazy/catalog`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            signal: AbortSignal.timeout(8000),
-            body: JSON.stringify({ models, active: getRunpodActiveModels() }),
-        });
-        if (!result.ok) {
-            throw new Error(`catalog returned ${result.status}`);
-        }
-        return true;
-    } catch (error) {
-        console.warn('SD: runpod catalog push failed', error);
-        return false;
-    }
-}
-/**
- * Rebuilds the RunPod model catalog editor in the settings UI.
- */
-function renderRunpodModels() {
-    const container = $('#sd_runpod_models_list');
-    if (!container.length) {
-        return;
-    }
-    container.empty();
-    const models = Array.isArray(extension_settings.sd.runpod_models) ? extension_settings.sd.runpod_models : [];
-    if (models.length === 0) {
-        container.append($('<small></small>').text('No models configured.'));
-        return;
-    }
-    models.forEach((model, index) => {
-        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: '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(); });
-        const downloadsInput = $('<textarea></textarea>').addClass('text_pole textarea_compact')
-            .attr({ rows: 2, placeholder: 'One file per line: <models-subpath> <url>\ne.g. unet/model.gguf https://huggingface.co/...' })
-            .val(model.downloads || '')
-            .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));
-    });
-}
-function onRunpodModelsAddClick() {
-    if (!Array.isArray(extension_settings.sd.runpod_models)) {
-        extension_settings.sd.runpod_models = [];
-    }
-    extension_settings.sd.runpod_models.push({ name: '', value: '', downloads: '' });
-    saveSettingsDebounced();
-    renderRunpodModels();
-}
-// #endregion
-/**
- * Rebuilds the custom wand entries list in the settings UI.
- */
-function renderCustomEntriesList() {
-    const container = $('#sd_custom_entries_list');
-    if (!container.length) {
-        return;
-    }
-    container.empty();
-    const entries = Array.isArray(extension_settings.sd.custom_entries) ? extension_settings.sd.custom_entries : [];
-    if (entries.length === 0) {
-        const empty = $('<small></small>')
-            .attr('data-i18n', 'No custom entries yet.')
-            .text('No custom entries yet.');
-        container.append(empty);
-        return;
-    }
-    for (const entry of entries) {
-        const preview = String(entry.prompt || '').replace(/\s+/g, ' ').trim();
-        const truncated = preview.length > 80 ? preview.slice(0, 80) + '…' : preview;
-        const titleEl = $('<div></div>').addClass('sd_custom_entry_title').text(entry.title);
-        const previewEl = $('<small></small>').addClass('sd_custom_entry_preview').text(truncated);
-        const textBlock = $('<div></div>').addClass('flex1 flexFlowColumn').append(titleEl).append(previewEl);
-        const editButton = $('<div></div>')
-            .addClass('menu_button menu_button_icon fa-solid fa-pencil')
-            .attr('data-entry-id', entry.id)
-            .attr('data-action', 'edit')
-            .attr('title', 'Edit')
-            .attr('data-i18n', '[title]Edit');
-        const deleteButton = $('<div></div>')
-            .addClass('menu_button menu_button_icon fa-solid fa-trash-can')
-            .attr('data-entry-id', entry.id)
-            .attr('data-action', 'delete')
-            .attr('title', 'Delete')
-            .attr('data-i18n', '[title]Delete');
-        const row = $('<div></div>')
-            .addClass('flex-container alignItemsCenter marginTopBot5 sd_custom_entry_row')
-            .append(textBlock)
-            .append(editButton)
-            .append(deleteButton);
-        container.append(row);
-    }
-}
-/**
- * Generates a unique id for a custom entry.
- * @returns {string} A unique identifier.
- */
-function getUniqueCustomEntryId() {
-    return crypto.randomUUID?.() ?? ('ce_' + Date.now() + '_' + Math.floor(Math.random() * 1e6));
-}
-/**
- * Opens a popup to create/edit a custom entry and returns the entered values.
- * @param {string} title Initial title value.
- * @param {string} prompt Initial prompt value.
- * @returns {Promise<{title: string, prompt: string} | null>} Entered values, or null if cancelled.
- */
-async function showCustomEntryPopup(title, prompt) {
-    const form = $('<div></div>').addClass('flex-container flexFlowColumn');
-    const titleLabel = $('<label></label>').attr('data-i18n', 'Title').text('Title');
-    const titleInput = $('<input>')
-        .addClass('text_pole')
-        .attr('type', 'text')
-        .attr('id', 'sd_custom_entry_title_input')
-        .val(title || '');
-    const promptLabel = $('<label></label>').attr('data-i18n', 'Prompt').text('Prompt');
-    const promptInput = $('<textarea></textarea>')
-        .addClass('text_pole textarea_compact')
-        .attr('id', 'sd_custom_entry_prompt_input')
-        .attr('rows', 5)
-        .val(prompt || '');
-    form.append(titleLabel).append(titleInput).append(promptLabel).append(promptInput);
-    const popup = new Popup(form, POPUP_TYPE.CONFIRM, '', { okButton: t`Save`, cancelButton: t`Cancel` });
-    const result = await popup.show();
-    if (!result) {
-        return null;
-    }
-    return {
-        title: String(titleInput.val() ?? '').trim(),
-        prompt: String(promptInput.val() ?? '').trim(),
-    };
-}
-async function onAddCustomEntryClick() {
-    const values = await showCustomEntryPopup('', '');
-    if (!values) {
-        return;
-    }
-    if (!values.title || !values.prompt) {
-        toastr.warning(t`Both a title and a prompt are required.`, t`Image Generation`);
-        return;
-    }
-    if (!Array.isArray(extension_settings.sd.custom_entries)) {
-        extension_settings.sd.custom_entries = [];
-    }
-    extension_settings.sd.custom_entries.push({
-        id: getUniqueCustomEntryId(),
-        title: values.title,
-        prompt: values.prompt,
-    });
-    saveSettingsDebounced();
-    renderCustomEntriesList();
-    renderCustomDropdownEntries();
-}
-async function onEditCustomEntryClick(id) {
-    const entries = Array.isArray(extension_settings.sd.custom_entries) ? extension_settings.sd.custom_entries : [];
-    const entry = entries.find(e => e.id === id);
-    if (!entry) {
-        return;
-    }
-    const values = await showCustomEntryPopup(entry.title, entry.prompt);
-    if (!values) {
-        return;
-    }
-    if (!values.title || !values.prompt) {
-        toastr.warning(t`Both a title and a prompt are required.`, t`Image Generation`);
-        return;
-    }
-    entry.title = values.title;
-    entry.prompt = values.prompt;
-    saveSettingsDebounced();
-    renderCustomEntriesList();
-    renderCustomDropdownEntries();
-}
-async function onDeleteCustomEntryClick(id) {
-    const entries = Array.isArray(extension_settings.sd.custom_entries) ? extension_settings.sd.custom_entries : [];
-    const index = entries.findIndex(e => e.id === id);
-    if (index === -1) {
-        return;
-    }
-    const confirmed = await callGenericPopup(t`Are you sure you want to delete the entry "${entries[index].title}"?`, POPUP_TYPE.CONFIRM, '', { okButton: t`Delete`, cancelButton: t`Cancel` });
-    if (!confirmed) {
-        return;
-    }
-    entries.splice(index, 1);
-    saveSettingsDebounced();
-    renderCustomEntriesList();
-    renderCustomDropdownEntries();
-}
-/**
- * Modifies prompt based on user inputs.
- * @param {string} prompt Prompt to refine
- * @param {object} [args] Additional arguments for refinement
- * @param {string} [args.negative] Negative prompt to prefill
- * @param {string} [args.resolution] Saved resolution to offer as a checkbox option
- * @returns {Promise<string>} Refined prompt
- */
-async function refinePrompt(prompt, args = null) {
-    if (extension_settings.sd.refine_mode) {
-        /** @type {import('../../popup.js').CustomPopupInput[]} */
-        const customInputs = [];
-        if (args?.negative) {
-            customInputs.push({
-                id: 'sd_refine_negative',
-                label: t`Negative prompt (optional)`,
-                type: 'textarea',
-                rows: 4,
-                defaultState: String(args.negative || ''),
-            });
-        }
-        if (args?.resolution) {
-            customInputs.push({
-                id: 'sd_use_saved_resolution',
-                label: t`Use saved resolution (${args.resolution})`,
-                type: 'checkbox',
-                defaultState: true,
-            });
-        }
-        const refinedPrompt = await Popup.show.input(
-            t`Review and edit the prompt:`,
-            t`Press "Cancel" to abort the image generation.`,
-            prompt.trim(),
-            {
-                rows: 8,
-                okButton: t`Continue`,
-                cancelButton: t`Cancel`,
-                customInputs,
-                onClose: (popup) => {
-                    if (!popup.result || !(popup.inputResults instanceof Map) || !args) {
-                        return;
-                    }
-                    const negativeInput = popup.inputResults.get('sd_refine_negative');
-                    const useSavedResolution = popup.inputResults.get('sd_use_saved_resolution');
-                    if (negativeInput) {
-                        args.negative = negativeInput.toString().trim();
-                    }
-                    if (!useSavedResolution) {
-                        args.resolution = null;
-                    }
-                },
-            });
-        if (refinedPrompt) {
-            return String(refinedPrompt);
-        } else {
-            throw new Error('Generation aborted by user.');
-        }
-    }
-    return prompt;
-}
-async function onChatChanged() {
-    if (this_chid === undefined || selected_group) {
-        $('#sd_character_prompt_block').hide();
-        return;
-    }
-    $('#sd_character_prompt_block').show();
-    const key = getCharaFilename(this_chid);
-    let characterPrompt = key ? (extension_settings.sd.character_prompts[key] || '') : '';
-    let negativePrompt = key ? (extension_settings.sd.character_negative_prompts[key] || '') : '';
-    const context = getContext();
-    const sharedPromptData = context?.characters[this_chid]?.data?.extensions?.sd_character_prompt;
-    const hasSharedData = sharedPromptData && typeof sharedPromptData === 'object';
-    if (typeof sharedPromptData?.positive === 'string' && !characterPrompt && sharedPromptData.positive) {
-        characterPrompt = sharedPromptData.positive;
-        extension_settings.sd.character_prompts[key] = characterPrompt;
-    }
-    if (typeof sharedPromptData?.negative === 'string' && !negativePrompt && sharedPromptData.negative) {
-        negativePrompt = sharedPromptData.negative;
-        extension_settings.sd.character_negative_prompts[key] = negativePrompt;
-    }
-    $('#sd_character_prompt').val(characterPrompt);
-    $('#sd_character_negative_prompt').val(negativePrompt);
-    $('#sd_character_prompt_share').prop('checked', hasSharedData);
-    await adjustElementScrollHeight();
-}
-async function adjustElementScrollHeight() {
-    if (CSS.supports('field-sizing', 'content') || !$('.sd_settings').is(':visible')) {
-        return;
-    }
-    await resetScrollHeight($('#sd_prompt_prefix'));
-    await resetScrollHeight($('#sd_negative_prompt'));
-    await resetScrollHeight($('#sd_character_prompt'));
-    await resetScrollHeight($('#sd_character_negative_prompt'));
-}
-async function onCharacterPromptInput() {
-    const key = getCharaFilename(this_chid);
-    extension_settings.sd.character_prompts[key] = $('#sd_character_prompt').val();
-    saveSettingsDebounced();
-    writePromptFieldsDebounced(this_chid);
-    if (CSS.supports('field-sizing', 'content')) return;
-    await resetScrollHeight($(this));
-}
-async function onCharacterNegativePromptInput() {
-    const key = getCharaFilename(this_chid);
-    extension_settings.sd.character_negative_prompts[key] = $('#sd_character_negative_prompt').val();
-    saveSettingsDebounced();
-    writePromptFieldsDebounced(this_chid);
-    if (CSS.supports('field-sizing', 'content')) return;
-    await resetScrollHeight($(this));
-}
-function getCharacterPrefix() {
-    if (this_chid === undefined || selected_group) {
-        return '';
-    }
-    const key = getCharaFilename(this_chid);
-    if (key) {
-        return extension_settings.sd.character_prompts[key] || '';
-    }
-    return '';
-}
-function getCharacterNegativePrefix() {
-    if (this_chid === undefined || selected_group) {
-        return '';
-    }
-    const key = getCharaFilename(this_chid);
-    if (key) {
-        return extension_settings.sd.character_negative_prompts[key] || '';
-    }
-    return '';
-}
-/**
- * Combines two prompt prefixes into one.
- * @param {string} str1 Base string
- * @param {string} str2 Secondary string
- * @param {string} macro Macro to replace with the secondary string
- * @returns {string} Combined string with a comma between them
- */
-function combinePrefixes(str1, str2, macro = '') {
-    // Remove leading/trailing white spaces and commas from the strings
-    const process = (s) => s.trim().replace(/^,|,$/g, '').trim();
-    if (!str2) {
-        return str1;
-    }
-    str1 = process(str1);
-    str2 = process(str2);
-    // Combine the strings with a comma between them)
-    const result = macro && str1.includes(macro) ? str1.replace(macro, str2) : `${str1}, ${str2},`;
-    return process(result);
-}
-function onRefineModeInput() {
-    extension_settings.sd.refine_mode = !!$('#sd_refine_mode').prop('checked');
-    saveSettingsDebounced();
-}
-function onFreeExtendInput() {
-    extension_settings.sd.free_extend = !!$('#sd_free_extend').prop('checked');
-    saveSettingsDebounced();
-}
-function onWandVisibleInput() {
-    extension_settings.sd.wand_visible = !!$('#sd_wand_visible').prop('checked');
-    saveSettingsDebounced();
-}
-function onCommandVisibleInput() {
-    extension_settings.sd.command_visible = !!$('#sd_command_visible').prop('checked');
-    saveSettingsDebounced();
-}
-function onInteractiveVisibleInput() {
-    extension_settings.sd.interactive_visible = !!$('#sd_interactive_visible').prop('checked');
-    saveSettingsDebounced();
-}
-function onToolVisibleInput() {
-    extension_settings.sd.tool_visible = !!$('#sd_tool_visible').prop('checked');
-    saveSettingsDebounced();
-}
-function onClipSkipInput() {
-    extension_settings.sd.clip_skip = Number($('#sd_clip_skip').val());
-    $('#sd_clip_skip_value').val(extension_settings.sd.clip_skip);
-    saveSettingsDebounced();
-}
-function onSeedInput() {
-    extension_settings.sd.seed = Number($('#sd_seed').val());
-    saveSettingsDebounced();
-}
-function onScaleInput() {
-    extension_settings.sd.scale = Number($('#sd_scale').val());
-    $('#sd_scale_value').val(extension_settings.sd.scale.toFixed(1));
-    saveSettingsDebounced();
-}
-function onStepsInput() {
-    extension_settings.sd.steps = Number($('#sd_steps').val());
-    $('#sd_steps_value').val(extension_settings.sd.steps);
-    saveSettingsDebounced();
-}
-async function onPromptPrefixInput() {
-    extension_settings.sd.prompt_prefix = $('#sd_prompt_prefix').val();
-    saveSettingsDebounced();
-    if (CSS.supports('field-sizing', 'content')) return;
-    await resetScrollHeight($(this));
-}
-async function onNegativePromptInput() {
-    extension_settings.sd.negative_prompt = $('#sd_negative_prompt').val();
-    saveSettingsDebounced();
-    if (CSS.supports('field-sizing', 'content')) return;
-    await resetScrollHeight($(this));
-}
-function onSamplerChange() {
-    extension_settings.sd.sampler = $('#sd_sampler').find(':selected').val();
-    saveSettingsDebounced();
-}
-function onADetailerFaceChange() {
-    extension_settings.sd.adetailer_face = !!$('#sd_adetailer_face').prop('checked');
-    saveSettingsDebounced();
-}
-const resolutionOptions = {
-    sd_res_512x512: { width: 512, height: 512, name: translate('512x512 (1:1, icons, profile pictures)', 'sd_res_512x512') },
-    sd_res_600x600: { width: 600, height: 600, name: translate('600x600 (1:1, icons, profile pictures)', 'sd_res_600x600') },
-    sd_res_512x768: { width: 512, height: 768, name: translate('512x768 (2:3, vertical character card)', 'sd_res_512x768') },
-    sd_res_768x512: { width: 768, height: 512, name: translate('768x512 (3:2, horizontal 35-mm movie film)', 'sd_res_768x512') },
-    sd_res_960x540: { width: 960, height: 540, name: translate('960x540 (16:9, horizontal wallpaper)', 'sd_res_960x540') },
-    sd_res_540x960: { width: 540, height: 960, name: translate('540x960 (9:16, vertical wallpaper)', 'sd_res_540x960') },
-    sd_res_1920x1088: { width: 1920, height: 1088, name: translate('1920x1088 (16:9, 1080p, horizontal wallpaper)', 'sd_res_1920x1088') },
-    sd_res_1088x1920: { width: 1088, height: 1920, name: translate('1088x1920 (9:16, 1080p, vertical wallpaper)', 'sd_res_1088x1920') },
-    sd_res_1280x720: { width: 1280, height: 720, name: translate('1280x720 (16:9, 720p, horizontal wallpaper)', 'sd_res_1280x720') },
-    sd_res_720x1280: { width: 720, height: 1280, name: translate('720x1280 (9:16, 720p, vertical wallpaper)', 'sd_res_720x1280') },
-    sd_res_1024x1024: { width: 1024, height: 1024, name: '1024x1024 (1:1, SDXL)' },
-    sd_res_1152x896: { width: 1152, height: 896, name: '1152x896 (9:7, SDXL)' },
-    sd_res_896x1152: { width: 896, height: 1152, name: '896x1152 (7:9, SDXL)' },
-    sd_res_1216x832: { width: 1216, height: 832, name: '1216x832 (19:13, SDXL)' },
-    sd_res_832x1216: { width: 832, height: 1216, name: '832x1216 (13:19, SDXL)' },
-    sd_res_1344x768: { width: 1344, height: 768, name: '1344x768 (4:3, SDXL)' },
-    sd_res_768x1344: { width: 768, height: 1344, name: '768x1344 (3:4, SDXL)' },
-    sd_res_1536x640: { width: 1536, height: 640, name: '1536x640 (24:10, SDXL)' },
-    sd_res_640x1536: { width: 640, height: 1536, name: '640x1536 (10:24, SDXL)' },
-    sd_res_1536x1024: { width: 1536, height: 1024, name: '1536x1024 (3:2, ChatGPT)' },
-    sd_res_1024x1536: { width: 1024, height: 1536, name: '1024x1536 (2:3, ChatGPT)' },
-    sd_res_1024x1792: { width: 1024, height: 1792, name: '1024x1792 (4:7, DALL-E)' },
-    sd_res_1792x1024: { width: 1792, height: 1024, name: '1792x1024 (7:4, DALL-E)' },
-    sd_res_1280x1280: { width: 1280, height: 1280, name: '1280x1280 (1:1, Z.AI)' },
-    sd_res_1568x1056: { width: 1568, height: 1056, name: '1568x1056 (3:2, Z.AI)' },
-    sd_res_1056x1568: { width: 1056, height: 1568, name: '1056x1568 (2:3, Z.AI)' },
-    sd_res_1472x1088: { width: 1472, height: 1088, name: '1472x1088 (4:3, Z.AI)' },
-    sd_res_1088x1472: { width: 1088, height: 1472, name: '1088x1472 (3:4, Z.AI)' },
-    sd_res_1728x960: { width: 1728, height: 960, name: '1728x960 (16:9, Z.AI)' },
-    sd_res_960x1728: { width: 960, height: 1728, name: '960x1728 (9:16, Z.AI)' },
-};
-function onResolutionChange() {
-    const selectedOption = $('#sd_resolution').val();
-    const selectedResolution = resolutionOptions[selectedOption];
-    if (!selectedResolution) {
-        console.warn(`Could not find resolution option for ${selectedOption}`);
-        return;
-    }
-    $('#sd_height').val(selectedResolution.height).trigger('input');
-    $('#sd_width').val(selectedResolution.width).trigger('input');
-}
-function onSchedulerChange() {
-    extension_settings.sd.scheduler = $('#sd_scheduler').find(':selected').val();
-    saveSettingsDebounced();
-}
-function onWidthInput() {
-    extension_settings.sd.width = Number($('#sd_width').val());
-    $('#sd_width_value').val(extension_settings.sd.width);
-    saveSettingsDebounced();
-}
-function onHeightInput() {
-    extension_settings.sd.height = Number($('#sd_height').val());
-    $('#sd_height_value').val(extension_settings.sd.height);
-    saveSettingsDebounced();
-}
-function onSwapDimensionsClick() {
-    const w = extension_settings.sd.height;
-    const h = extension_settings.sd.width;
-    extension_settings.sd.width = w;
-    extension_settings.sd.height = h;
-    $('#sd_width').val(w).trigger('input');
-    $('#sd_height').val(h).trigger('input');
-    saveSettingsDebounced();
-}
-async function onSourceChange() {
-    extension_settings.sd.source = $('#sd_source').find(':selected').val();
-    extension_settings.sd.model = null;
-    extension_settings.sd.sampler = null;
-    extension_settings.sd.scheduler = null;
-    extension_settings.sd.vae = null;
-    toggleSourceControls();
-    saveSettingsDebounced();
-    await loadSettingOptions();
-}
-async function onComfyTypeChange() {
-    extension_settings.sd.comfy_type = $('#sd_comfy_type').find(':selected').val();
-    await onSourceChange();
-}
-function onFunctionToolInput() {
-    extension_settings.sd.function_tool = !!$(this).prop('checked');
-    saveSettingsDebounced();
-    registerFunctionTool();
-}
-async function onOpenAiStyleSelect() {
-    extension_settings.sd.openai_style = String($('#sd_openai_style').find(':selected').val());
-    saveSettingsDebounced();
-}
-async function onOpenAiQualitySelect() {
-    extension_settings.sd.openai_quality = String($('#sd_openai_quality').find(':selected').val());
-    saveSettingsDebounced();
-}
-async function onOpenAiDurationSelect() {
-    extension_settings.sd.openai_duration = String($('#sd_openai_duration').find(':selected').val());
-    saveSettingsDebounced();
-}
-async function onViewAnlasClick() {
-    const result = await loadNovelSubscriptionData();
-    if (!result) {
-        toastr.warning('Are you subscribed?', 'Could not load NovelAI subscription data');
-        return;
-    }
-    const anlas = getNovelAnlas();
-    const unlimitedGeneration = getNovelUnlimitedImageGeneration();
-    toastr.info(`Free image generation: ${unlimitedGeneration ? 'Yes' : 'No'}`, `Anlas: ${anlas}`);
-}
-function onNovelAnlasGuardInput() {
-    extension_settings.sd.novel_anlas_guard = !!$('#sd_novel_anlas_guard').prop('checked');
-    saveSettingsDebounced();
-}
-function onNovelSmInput() {
-    extension_settings.sd.novel_sm = !!$('#sd_novel_sm').prop('checked');
-    saveSettingsDebounced();
-    if (!extension_settings.sd.novel_sm) {
-        $('#sd_novel_sm_dyn').prop('checked', false).prop('disabled', true).trigger('input');
-    } else {
-        $('#sd_novel_sm_dyn').prop('disabled', false);
-    }
-}
-function onNovelSmDynInput() {
-    extension_settings.sd.novel_sm_dyn = !!$('#sd_novel_sm_dyn').prop('checked');
-    saveSettingsDebounced();
-}
-function onNovelDecrisperInput() {
-    extension_settings.sd.novel_decrisper = !!$('#sd_novel_decrisper').prop('checked');
-    saveSettingsDebounced();
-}
-function onNovelVarietyBoostInput() {
-    extension_settings.sd.novel_variety_boost = !!$('#sd_novel_variety_boost').prop('checked');
-    saveSettingsDebounced();
-}
-function onPollinationsEnhanceInput() {
-    extension_settings.sd.pollinations_enhance = !!$('#sd_pollinations_enhance').prop('checked');
-    saveSettingsDebounced();
-}
-function onHordeNsfwInput() {
-    extension_settings.sd.horde_nsfw = !!$(this).prop('checked');
-    saveSettingsDebounced();
-}
-function onHordeKarrasInput() {
-    extension_settings.sd.horde_karras = !!$(this).prop('checked');
-    saveSettingsDebounced();
-}
-function onHordeSanitizeInput() {
-    extension_settings.sd.horde_sanitize = !!$(this).prop('checked');
-    saveSettingsDebounced();
-}
-function onRestoreFacesInput() {
-    extension_settings.sd.restore_faces = !!$(this).prop('checked');
-    saveSettingsDebounced();
-}
-function onHighResFixInput() {
-    extension_settings.sd.enable_hr = !!$(this).prop('checked');
-    saveSettingsDebounced();
-}
-function onAutoUrlInput() {
-    extension_settings.sd.auto_url = $('#sd_auto_url').val();
-    saveSettingsDebounced();
-}
-function onAutoAuthInput() {
-    extension_settings.sd.auto_auth = $('#sd_auto_auth').val();
-    saveSettingsDebounced();
-}
-function onSdcppUrlInput() {
-    extension_settings.sd.sdcpp_url = $('#sd_sdcpp_url').val();
-    saveSettingsDebounced();
-}
-function onVladUrlInput() {
-    extension_settings.sd.vlad_url = $('#sd_vlad_url').val();
-    saveSettingsDebounced();
-}
-function onVladAuthInput() {
-    extension_settings.sd.vlad_auth = $('#sd_vlad_auth').val();
-    saveSettingsDebounced();
-}
-function onDrawthingsUrlInput() {
-    extension_settings.sd.drawthings_url = $('#sd_drawthings_url').val();
-    saveSettingsDebounced();
-}
-function onDrawthingsAuthInput() {
-    extension_settings.sd.drawthings_auth = $('#sd_drawthings_auth').val();
-    saveSettingsDebounced();
-}
-function onHrUpscalerChange() {
-    extension_settings.sd.hr_upscaler = $('#sd_hr_upscaler').find(':selected').val();
-    saveSettingsDebounced();
-}
-function onHrScaleInput() {
-    extension_settings.sd.hr_scale = Number($('#sd_hr_scale').val());
-    $('#sd_hr_scale_value').val(extension_settings.sd.hr_scale.toFixed(1));
-    saveSettingsDebounced();
-}
-function onDenoisingStrengthInput() {
-    extension_settings.sd.denoising_strength = Number($('#sd_denoising_strength').val());
-    $('#sd_denoising_strength_value').val(extension_settings.sd.denoising_strength.toFixed(2));
-    saveSettingsDebounced();
-}
-function onLoraStrengthInput() {
-    extension_settings.sd.lora_strength = Number($('#sd_lora_strength').val());
-    $('#sd_lora_strength_value').val(extension_settings.sd.lora_strength.toFixed(2));
-    saveSettingsDebounced();
-}
-function onHrSecondPassStepsInput() {
-    extension_settings.sd.hr_second_pass_steps = Number($('#sd_hr_second_pass_steps').val());
-    $('#sd_hr_second_pass_steps_value').val(extension_settings.sd.hr_second_pass_steps);
-    saveSettingsDebounced();
-}
-function onComfyUrlInput() {
-    extension_settings.sd.comfy_url = String($('#sd_comfy_url').val());
-    saveSettingsDebounced();
-}
-function onComfyRunPodUrlInput() {
-    extension_settings.sd.comfy_runpod_url = String($('#sd_comfy_runpod_url').val());
-    saveSettingsDebounced();
-}
-function onHFModelInput() {
-    extension_settings.sd.huggingface_model_id = $('#sd_huggingface_model_id').val();
-    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();
-}
-function onBflUpsamplingInput() {
-    extension_settings.sd.bfl_upsampling = !!$('#sd_bfl_upsampling').prop('checked');
-    saveSettingsDebounced();
-}
-function onStabilityStylePresetChange() {
-    extension_settings.sd.stability_style_preset = String($('#sd_stability_style_preset').val());
-    saveSettingsDebounced();
-}
-async function changeComfyWorkflow(_, name) {
-    name = name.replace(/(\.json)?$/i, '.json');
-    if ($(`#sd_comfy_workflow > [value="${name}"]`).length > 0) {
-        extension_settings.sd.comfy_workflow = name;
-        $('#sd_comfy_workflow').val(extension_settings.sd.comfy_workflow);
-        saveSettingsDebounced();
-    } else {
-        toastr.error(`ComfyUI Workflow "${name}" does not exist.`);
-    }
-    return '';
-}
-async function validateAutoUrl() {
-    try {
-        if (!extension_settings.sd.auto_url) {
-            throw new Error('URL is not set.');
-        }
-        const result = await fetch('/api/sd/ping', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD WebUI returned an error.');
-        }
-        await loadSettingOptions();
-        toastr.success('SD WebUI API connected.');
-    } catch (error) {
-        toastr.error(`Could not validate SD WebUI API: ${error.message}`);
-    }
-}
-async function validateSdcppUrl() {
-    try {
-        if (!extension_settings.sd.sdcpp_url) {
-            throw new Error('URL is not set.');
-        }
-        const result = await fetch('/api/sd/sdcpp/ping', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify({ url: extension_settings.sd.sdcpp_url }),
-        });
-        if (!result.ok) {
-            throw new Error('stable-diffusion.cpp server returned an error.');
-        }
-        await loadSettingOptions();
-        toastr.success('stable-diffusion.cpp server connected.');
-    } catch (error) {
-        toastr.error(`Could not validate stable-diffusion.cpp server: ${error.message}`);
-    }
-}
-async function validateDrawthingsUrl() {
-    try {
-        if (!extension_settings.sd.drawthings_url) {
-            throw new Error('URL is not set.');
-        }
-        const result = await fetch('/api/sd/drawthings/ping', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD Drawthings returned an error.');
-        }
-        await loadSettingOptions();
-        toastr.success('SD Drawthings API connected.');
-    } catch (error) {
-        toastr.error(`Could not validate SD Drawthings API: ${error.message}`);
-    }
-}
-async function validateVladUrl() {
-    try {
-        if (!extension_settings.sd.vlad_url) {
-            throw new Error('URL is not set.');
-        }
-        const result = await fetch('/api/sd/ping', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD.Next returned an error.');
-        }
-        await loadSettingOptions();
-        toastr.success('SD.Next API connected.');
-    } catch (error) {
-        toastr.error(`Could not validate SD.Next API: ${error.message}`);
-    }
-}
-async function validateComfyUrl() {
-    try {
-        if (!extension_settings.sd.comfy_url) {
-            throw new Error('URL is not set.');
-        }
-        const result = await fetch('/api/sd/comfy/ping', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify({
-                url: extension_settings.sd.comfy_url,
-            }),
-        });
-        if (!result.ok) {
-            throw new Error('ComfyUI returned an error.');
-        }
-        await loadSettingOptions();
-        toastr.success('ComfyUI API connected.');
-    } catch (error) {
-        toastr.error(`Could not validate ComfyUI API: ${error.message}`);
-    }
-}
-async function validateComfyRunPodUrl() {
-    try {
-        if (!extension_settings.sd.comfy_runpod_url) {
-            throw new Error('URL is not set.');
-        }
-        const result = await fetch('/api/sd/comfyrunpod/ping', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify({
-                url: extension_settings.sd.comfy_runpod_url,
-            }),
-        });
-        if (!result.ok) {
-            throw new Error('ComfyUI RunPod returned an error.');
-        }
-        await loadSettingOptions();
-        toastr.success('ComfyUI RunPod API connected.');
-    } catch (error) {
-        toastr.error(`Could not validate ComfyUI RunPod API: ${error.message}`);
-    }
-}
-async function onModelChange() {
-    const selectedModel = $('#sd_model').find(':selected');
-    extension_settings.sd.model = selectedModel.val();
-    rememberWorkflowPref('model', extension_settings.sd.model);
-    saveSettingsDebounced();
-    // Keep the proxy's stored selection current, but catalog updates never
-    // download, provision, or start a pod. Warm up applies the selection.
-    if (isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
-        pushRunpodCatalog();
-    }
-    if (extension_settings.sd.model && extension_settings.sd.source === sources.electronhub) {
-        const cachedModel = selectedModel.data('model');
-        const models = cachedModel ? [cachedModel] : await loadElectronHubModels();
-        ensureElectronHubQualitySelect(models);
-    }
-    switchModelSpecificControls(extension_settings.sd.model);
-    const updateRemoteModelSources = [
-        sources.auto,
-        sources.vlad,
-        sources.extras,
-    ];
-    if (!updateRemoteModelSources.includes(extension_settings.sd.source)) {
-        return;
-    }
-    toastr.info('Updating remote model...', 'Please wait');
-    if (extension_settings.sd.source === sources.extras) {
-        await updateExtrasRemoteModel();
-    }
-    if (extension_settings.sd.source === sources.auto || extension_settings.sd.source === sources.vlad) {
-        await updateAutoRemoteModel();
-    }
-    toastr.success('Model successfully loaded!', 'Image Generation');
-}
-async function getAutoRemoteModel() {
-    try {
-        const result = await fetch('/api/sd/get-model', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD WebUI returned an error.');
-        }
-        return await result.text();
-    } catch (error) {
-        console.error(error);
-        return null;
-    }
-}
-async function getDrawthingsRemoteModel() {
-    try {
-        const result = await fetch('/api/sd/drawthings/get-model', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD DrawThings API returned an error.');
-        }
-        return await result.text();
-    } catch (error) {
-        console.error(error);
-        return null;
-    }
-}
-async function onVaeChange() {
-    extension_settings.sd.vae = $('#sd_vae').find(':selected').val();
-}
-async function getAutoRemoteUpscalers() {
-    try {
-        const result = await fetch('/api/sd/upscalers', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD WebUI returned an error.');
-        }
-        return await result.json();
-    } catch (error) {
-        console.error(error);
-        return [extension_settings.sd.hr_upscaler];
-    }
-}
-async function getAutoRemoteSchedulers() {
-    try {
-        const result = await fetch('/api/sd/schedulers', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD WebUI returned an error.');
-        }
-        return await result.json();
-    } catch (error) {
-        console.error(error);
-        return ['N/A'];
-    }
-}
-async function getVladRemoteUpscalers() {
-    try {
-        const result = await fetch('/api/sd/sd-next/upscalers', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD.Next returned an error.');
-        }
-        return await result.json();
-    } catch (error) {
-        console.error(error);
-        return [extension_settings.sd.hr_upscaler];
-    }
-}
-async function getDrawthingsRemoteUpscalers() {
-    try {
-        const result = await fetch('/api/sd/drawthings/get-upscaler', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD DrawThings API returned an error.');
-        }
-        const data = await result.text();
-        return data ? [data] : ['N/A'];
-    } catch (error) {
-        console.error(error);
-        return ['N/A'];
-    }
-}
-async function updateAutoRemoteModel() {
-    try {
-        const result = await fetch('/api/sd/set-model', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify({ ...getSdRequestBody(), model: extension_settings.sd.model }),
-        });
-        if (!result.ok) {
-            throw new Error('SD WebUI returned an error.');
-        }
-        console.log('Model successfully updated on SD WebUI remote.');
-    } catch (error) {
-        console.error(error);
-        toastr.error(`Could not update SD WebUI model: ${error.message}`);
-    }
-}
-async function updateExtrasRemoteModel() {
-    const url = new URL(getApiUrl());
-    url.pathname = '/api/image/model';
-    const getCurrentModelResult = await doExtrasFetch(url, {
-        method: 'POST',
-        body: JSON.stringify({ model: extension_settings.sd.model }),
-    });
-    if (getCurrentModelResult.ok) {
-        console.log('Model successfully updated on SD remote.');
-    }
-}
-async function loadSamplers() {
-    $('#sd_sampler').empty();
-    let samplers = [];
-    switch (extension_settings.sd.source) {
-        case sources.extras:
-            samplers = await loadExtrasSamplers();
-            break;
-        case sources.horde:
-            samplers = await loadHordeSamplers();
-            break;
-        case sources.auto:
-            samplers = await loadAutoSamplers();
-            break;
-        case sources.sdcpp:
-            samplers = await loadSdcppSamplers();
-            break;
-        case sources.drawthings:
-            samplers = await loadDrawthingsSamplers();
-            break;
-        case sources.novel:
-            samplers = await loadNovelSamplers();
-            break;
-        case sources.vlad:
-            samplers = await loadVladSamplers();
-            break;
-        case sources.openai:
-            samplers = ['N/A'];
-            break;
-        case sources.aimlapi:
-            samplers = ['N/A'];
-            break;
-        case sources.comfy:
-            samplers = await loadComfySamplers();
-            break;
-        case sources.togetherai:
-            samplers = ['N/A'];
-            break;
-        case sources.pollinations:
-            samplers = ['N/A'];
-            break;
-        case sources.stability:
-            samplers = ['N/A'];
-            break;
-        case sources.huggingface:
-            samplers = ['N/A'];
-            break;
-        case sources.chutes:
-            samplers = ['N/A'];
-            break;
-        case sources.electronhub:
-            samplers = ['N/A'];
-            break;
-        case sources.nanogpt:
-            samplers = ['N/A'];
-            break;
-        case sources.bfl:
-            samplers = ['N/A'];
-            break;
-        case sources.falai:
-            samplers = ['N/A'];
-            break;
-        case sources.xai:
-            samplers = ['N/A'];
-            break;
-        case sources.google:
-            samplers = ['N/A'];
-            break;
-        case sources.zai:
-            samplers = ['N/A'];
-            break;
-        case sources.openrouter:
-            samplers = ['N/A'];
-            break;
-        case sources.workersai:
-            samplers = ['N/A'];
-            break;
-    }
-    for (const sampler of samplers) {
-        const option = document.createElement('option');
-        option.innerText = sampler;
-        option.value = sampler;
-        option.selected = sampler === extension_settings.sd.sampler;
-        $('#sd_sampler').append(option);
-    }
-    if (!extension_settings.sd.sampler && samplers.length > 0) {
-        extension_settings.sd.sampler = samplers[0];
-        $('#sd_sampler').val(extension_settings.sd.sampler).trigger('change');
-    }
-}
-async function loadHordeSamplers() {
-    const result = await fetch('/api/horde/sd-samplers', {
-        method: 'POST',
-        headers: getRequestHeaders({ omitContentType: true }),
-    });
-    if (result.ok) {
-        return await result.json();
-    }
-    return [];
-}
-async function loadExtrasSamplers() {
-    if (!modules.includes('sd')) {
-        return [];
-    }
-    const url = new URL(getApiUrl());
-    url.pathname = '/api/image/samplers';
-    const result = await doExtrasFetch(url);
-    if (result.ok) {
-        const data = await result.json();
-        return data.samplers;
-    }
-    return [];
-}
-async function loadAutoSamplers() {
-    if (!extension_settings.sd.auto_url) {
-        return [];
-    }
-    try {
-        const result = await fetch('/api/sd/samplers', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD WebUI returned an error.');
-        }
-        return await result.json();
-    } catch (error) {
-        return [];
-    }
-}
-async function loadSdcppModels() {
-    if (!extension_settings.sd.sdcpp_url) {
-        return [{ value: '', text: 'N/A' }];
-    }
-    try {
-        const result = await fetch('/api/sd/sdcpp/models', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify({ url: extension_settings.sd.sdcpp_url }),
-        });
-        if (!result.ok) {
-            return [{ value: '', text: 'N/A' }];
-        }
-        const data = await result.json();
-        if (data?.data?.length > 0) {
-            return data.data.map(model => ({ value: model.id, text: model.name || model.id }));
-        }
-    } catch (error) {
-        console.error('Failed to load sd.cpp models:', error);
-    }
-    return [{ value: '', text: 'N/A' }];
-}
-async function loadSdcppSamplers() {
-    // The sdcpp server does not provide an API for samplers, so we return the known list.
-    return ['euler', 'euler_a', 'heun', 'dpm2', 'dpm++2s_a', 'dpm++2m', 'dpm++2mv2', 'ipndm', 'ipndm_v', 'lcm', 'ddim_trailing', 'tcd'];
-}
-async function loadDrawthingsSamplers() {
-    // The app developer doesn't provide an API to get these yet
-    return [
-        'UniPC',
-        'DPM++ 2M Karras',
-        'Euler a',
-        'DPM++ SDE Karras',
-        'PLMS',
-        'DDIM',
-        'LCM',
-        'Euler A Substep',
-        'DPM++ SDE Substep',
-        'TCD',
-    ];
-}
-async function loadVladSamplers() {
-    if (!extension_settings.sd.vlad_url) {
-        return [];
-    }
-    try {
-        const result = await fetch('/api/sd/samplers', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD.Next returned an error.');
-        }
-        return await result.json();
-    } catch (error) {
-        return [];
-    }
-}
-async function loadNovelSamplers() {
-    return [
-        'k_euler_ancestral',
-        'k_euler',
-        'k_dpmpp_2m',
-        'k_dpmpp_sde',
-        'k_dpmpp_2s_ancestral',
-        'k_dpm_fast',
-        'ddim',
-    ];
-}
-async function loadComfySamplers() {
-    if (extension_settings.sd.comfy_type === comfyTypes.runpod_serverless) {
-        return ['N/A'];
-    }
-    if (isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
-        // Do not query /object_info through a cold lazy proxy on page load.
-        return extension_settings.sd.sampler ? [extension_settings.sd.sampler] : [];
-    }
-    if (!extension_settings.sd.comfy_url) {
-        return [];
-    }
-    try {
-        const result = await fetch('/api/sd/comfy/samplers', {
-            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 [];
-    }
-}
-async function loadModels() {
-    $('#sd_model').empty();
-    let models = [];
-    switch (extension_settings.sd.source) {
-        case sources.extras:
-            models = await loadExtrasModels();
-            break;
-        case sources.horde:
-            models = await loadHordeModels();
-            break;
-        case sources.auto:
-            models = await loadAutoModels();
-            break;
-        case sources.sdcpp:
-            models = await loadSdcppModels();
-            break;
-        case sources.drawthings:
-            models = await loadDrawthingsModels();
-            break;
-        case sources.novel:
-            models = await loadNovelModels();
-            break;
-        case sources.vlad:
-            models = await loadVladModels();
-            break;
-        case sources.openai:
-            models = await loadOpenAiModels();
-            break;
-        case sources.aimlapi:
-            models = await loadAimlapiModels();
-            break;
-        case sources.comfy:
-            models = await loadComfyModels();
-            break;
-        case sources.togetherai:
-            models = await loadTogetherAIModels();
-            break;
-        case sources.pollinations:
-            models = await loadPollinationsModels();
-            break;
-        case sources.stability:
-            models = await loadStabilityModels();
-            break;
-        case sources.huggingface:
-            models = [{ value: '', text: t`<Enter Model ID above>` }];
-            break;
-        case sources.chutes:
-            models = await loadChutesModels();
-            break;
-        case sources.electronhub:
-            models = await loadElectronHubModels();
-            break;
-        case sources.nanogpt:
-            models = await loadNanoGPTModels();
-            break;
-        case sources.bfl:
-            models = await loadBflModels();
-            break;
-        case sources.falai:
-            models = await loadFalaiModels();
-            break;
-        case sources.xai:
-            models = await loadXAIModels();
-            break;
-        case sources.google:
-            models = await loadGoogleModels();
-            break;
-        case sources.zai:
-            models = await loadZaiModels();
-            break;
-        case sources.openrouter:
-            models = await loadOpenRouterModels();
-            break;
-        case sources.workersai:
-            models = await loadWorkersAIImageModels();
-            break;
-    }
-    if (extension_settings.sd.source === sources.electronhub) {
-        ensureElectronHubQualitySelect(models);
-    }
-    switchModelSpecificControls(extension_settings.sd.model);
-    for (const model of models) {
-        const option = document.createElement('option');
-        option.innerText = model.text;
-        option.value = model.value;
-        option.selected = model.value === extension_settings.sd.model;
-        $(option).data('model', model);
-        $('#sd_model').append(option);
-    }
-    if (!extension_settings.sd.model && models.length > 0) {
-        extension_settings.sd.model = models[0].value;
-        $('#sd_model').val(extension_settings.sd.model).trigger('change');
-    }
-}
-/**
- * Show or hide model-specific controls based on the selected model.
- * @param {string} modelId Model ID
- */
-function switchModelSpecificControls(modelId) {
-    const modelControls = $('.sd_settings [data-sd-model]');
-    modelControls.hide();
-    if (!modelId) {
-        return;
-    }
-    modelControls.each(function () {
-        const models = String($(this).attr('data-sd-model') || '').split(',').map(m => m.trim());
-        $(this).toggle(models.some(m => modelId.includes(m)));
-    });
-}
-/**
- * Ensure the Electron Hub quality select is populated based on the selected model.
- * @param {any[]} models Array of models
- */
-function ensureElectronHubQualitySelect(models) {
-    try {
-        const modelId = String(extension_settings.sd.model || '');
-        if (!modelId) return;
-        const model = Array.isArray(models) ? models.find(m => String(m?.id) === modelId) : undefined;
-        const qualities = Array.isArray(model?.qualities) ? model.qualities : undefined;
-        const $qualityRow = $('#sd_electronhub_quality_row');
-        const $select = $('#sd_electronhub_quality');
-        $qualityRow.toggle(!!qualities && qualities.length > 0);
-        $select.empty();
-        if (!qualities || qualities.length === 0) {
-            extension_settings.sd.electronhub_quality = undefined;
-            saveSettingsDebounced();
-            return;
-        }
-        for (const q of qualities) {
-            const opt = document.createElement('option');
-            opt.value = String(q);
-            opt.textContent = String(q);
-            opt.selected = String(q) === String(extension_settings.sd.electronhub_quality || '');
-            $select.append(opt);
-        }
-        if (!$select.val()) {
-            const first = String(qualities[0]);
-            extension_settings.sd.electronhub_quality = first;
-            $select.val(first);
-            saveSettingsDebounced();
-        }
-    } catch (e) {
-        console.error(e);
-    }
-}
-async function loadStabilityModels() {
-    $('#sd_stability_key').toggleClass('success', !!secret_state[SECRET_KEYS.STABILITY]);
-    return [
-        { value: 'stable-image-ultra', text: 'Stable Image Ultra' },
-        { value: 'stable-image-core', text: 'Stable Image Core' },
-        { value: 'stable-diffusion-3', text: 'Stable Diffusion 3' },
-    ];
-}
-async function loadBflModels() {
-    $('#sd_bfl_key').toggleClass('success', !!secret_state[SECRET_KEYS.BFL]);
-    return [
-        { value: 'flux-pro-1.1-ultra', text: 'flux-pro-1.1-ultra' },
-        { value: 'flux-pro-1.1', text: 'flux-pro-1.1' },
-        { value: 'flux-pro', text: 'flux-pro' },
-        { value: 'flux-dev', text: 'flux-dev' },
-    ];
-}
-async function loadFalaiModels() {
-    $('#sd_falai_key').toggleClass('success', !!secret_state[SECRET_KEYS.FALAI]);
-    const result = await fetch('/api/sd/falai/models', {
-        method: 'POST',
-        headers: getRequestHeaders({ omitContentType: true }),
-    });
-    if (result.ok) {
-        return await result.json();
-    }
-    return [];
-}
-async function loadXAIModels() {
-    return [
-        { value: 'grok-imagine-image', text: 'grok-imagine-image' },
-        { value: 'grok-imagine-image-pro', text: 'grok-imagine-image-pro' },
-    ];
-}
-async function loadWorkersAIImageModels() {
-    $('#sd_cf_workers_key').toggleClass('success', !!secret_state[SECRET_KEYS.WORKERS_AI]);
-    if (!secret_state[SECRET_KEYS.WORKERS_AI]) {
-        return [];
-    }
-    if (!oai_settings.workers_ai_account_id) {
-        toastr.warning('Workers AI account ID is required. Save it in the "API Connections" panel.', 'Image Generation');
-        return [];
-    }
-    const result = await fetch('/api/sd/workersai/models', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        body: JSON.stringify({
-            account_id: oai_settings.workers_ai_account_id,
-        }),
-    });
-    if (result.ok) {
-        return await result.json();
-    }
-    return [];
-}
-async function loadPollinationsModels() {
-    $('#sd_pollinations_key').toggleClass('success', !!secret_state[SECRET_KEYS.POLLINATIONS]);
-    const result = await fetch('/api/sd/pollinations/models', {
-        method: 'POST',
-        headers: getRequestHeaders({ omitContentType: true }),
-    });
-    if (result.ok) {
-        return await result.json();
-    }
-    return [];
-}
-async function loadTogetherAIModels() {
-    if (!secret_state[SECRET_KEYS.TOGETHERAI]) {
-        console.debug('TogetherAI API key is not set.');
-        return [];
-    }
-    const result = await fetch('/api/sd/together/models', {
-        method: 'POST',
-        headers: getRequestHeaders({ omitContentType: true }),
-    });
-    if (result.ok) {
-        return await result.json();
-    }
-    return [];
-}
-async function loadChutesModels() {
-    if (!secret_state[SECRET_KEYS.CHUTES]) {
-        console.debug('Chutes API key is not set.');
-        return [];
-    }
-    const result = await fetch('/api/sd/chutes/models', {
-        method: 'POST',
-        headers: getRequestHeaders({ omitContentType: true }),
-    });
-    if (result.ok) {
-        const models = await result.json();
-        console.debug('Loaded Chutes image models:', models);
-        return models;
-    }
-    console.warn('Failed to load Chutes models:', result.status);
-    return [];
-}
-async function loadElectronHubModels() {
-    if (!secret_state[SECRET_KEYS.ELECTRONHUB]) {
-        console.debug('Electron Hub API key is not set.');
-        return [];
-    }
-    const result = await fetch('/api/sd/electronhub/models', {
-        method: 'POST',
-        headers: getRequestHeaders({ omitContentType: true }),
-    });
-    function getModelName(model) {
-        const name = String(model?.name || model?.id || '');
-        const premium = model?.premium_model ? ' | Premium' : '';
-        let price = 'Unknown';
-        if (model?.pricing?.type === 'per_image') {
-            const coeff = Number(model.pricing.coefficient);
-            if (!isNaN(coeff)) {
-                price = `$${coeff}/image`;
-            }
-        }
-        return `${name} | ${price}${premium}`;
-    }
-    if (result.ok) {
-        /** @type {any[]} */
-        const data = await result.json();
-        return Array.isArray(data) ? data.map(m => ({ ...m, text: getModelName(m) })) : [];
-    }
-    return [];
-}
-async function loadNanoGPTModels() {
-    if (!secret_state[SECRET_KEYS.NANOGPT]) {
-        console.debug('NanoGPT API key is not set.');
-        return [];
-    }
-    const result = await fetch('/api/sd/nanogpt/models', {
-        method: 'POST',
-        headers: getRequestHeaders({ omitContentType: true }),
-    });
-    if (result.ok) {
-        return await result.json();
-    }
-    return [];
-}
-async function loadHordeModels() {
-    const result = await fetch('/api/horde/sd-models', {
-        method: 'POST',
-        headers: getRequestHeaders({ omitContentType: true }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        data.sort((a, b) => b.count - a.count);
-        return data.map(x => ({
-            value: x.name,
-            text: `${x.name} (ETA: ${x.eta}s, Queue: ${x.queued}, Workers: ${x.count})`,
-        }));
-    }
-    return [];
-}
-async function loadExtrasModels() {
-    if (!modules.includes('sd')) {
-        return [];
-    }
-    const url = new URL(getApiUrl());
-    url.pathname = '/api/image/model';
-    const getCurrentModelResult = await doExtrasFetch(url);
-    if (getCurrentModelResult.ok) {
-        const data = await getCurrentModelResult.json();
-        extension_settings.sd.model = data.model;
-    }
-    url.pathname = '/api/image/models';
-    const getModelsResult = await doExtrasFetch(url);
-    if (getModelsResult.ok) {
-        const data = await getModelsResult.json();
-        return data.models.map(x => ({ value: x, text: x }));
-    }
-    return [];
-}
-async function loadAutoModels() {
-    if (!extension_settings.sd.auto_url) {
-        return [];
-    }
-    try {
-        const currentModel = await getAutoRemoteModel();
-        if (currentModel) {
-            extension_settings.sd.model = currentModel;
-        }
-        const result = await fetch('/api/sd/models', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD WebUI returned an error.');
-        }
-        const upscalers = await getAutoRemoteUpscalers();
-        if (Array.isArray(upscalers) && upscalers.length > 0) {
-            $('#sd_hr_upscaler').empty();
-            for (const upscaler of upscalers) {
-                const option = document.createElement('option');
-                option.innerText = upscaler;
-                option.value = upscaler;
-                option.selected = upscaler === extension_settings.sd.hr_upscaler;
-                $('#sd_hr_upscaler').append(option);
-            }
-        }
-        return await result.json();
-    } catch (error) {
-        return [];
-    }
-}
-async function loadDrawthingsModels() {
-    if (!extension_settings.sd.drawthings_url) {
-        return [];
-    }
-    try {
-        const currentModel = await getDrawthingsRemoteModel();
-        if (currentModel) {
-            extension_settings.sd.model = currentModel;
-        }
-        const data = [{ value: currentModel, text: currentModel }];
-        const upscalers = await getDrawthingsRemoteUpscalers();
-        if (Array.isArray(upscalers) && upscalers.length > 0) {
-            $('#sd_hr_upscaler').empty();
-            for (const upscaler of upscalers) {
-                const option = document.createElement('option');
-                option.innerText = upscaler;
-                option.value = upscaler;
-                option.selected = upscaler === extension_settings.sd.hr_upscaler;
-                $('#sd_hr_upscaler').append(option);
-            }
-        }
-        return data;
-    } catch (error) {
-        console.log('Error loading DrawThings API models:', error);
-        return [];
-    }
-}
-async function loadOpenAiModels() {
-    return [
-        { value: 'gpt-image-2', text: 'gpt-image-2' },
-        { value: 'gpt-image-2-2026-04-21', text: 'gpt-image-2-2026-04-21' },
-        { value: 'gpt-image-1.5', text: 'gpt-image-1.5' },
-        { value: 'gpt-image-1-mini', text: 'gpt-image-1-mini' },
-        { value: 'gpt-image-1', text: 'gpt-image-1' },
-        { value: 'chatgpt-image-latest', text: 'chatgpt-image-latest' },
-        { value: 'dall-e-3', text: 'dall-e-3' },
-        { value: 'dall-e-2', text: 'dall-e-2' },
-        { value: 'sora-2', text: 'sora-2' },
-        { value: 'sora-2-pro', text: 'sora-2-pro' },
-    ];
-}
-async function loadAimlapiModels() {
-    $('#sd_aimlapi_key').toggleClass('success', !!secret_state[SECRET_KEYS.AIMLAPI]);
-    const result = await fetch('/api/sd/aimlapi/models', {
-        method: 'POST',
-        headers: getRequestHeaders({ omitContentType: true }),
-    });
-    if (!result.ok) {
-        return [];
-    }
-    const json = await result.json();
-    return (json.data || []);
-}
-async function loadVladModels() {
-    if (!extension_settings.sd.vlad_url) {
-        return [];
-    }
-    try {
-        const currentModel = await getAutoRemoteModel();
-        if (currentModel) {
-            extension_settings.sd.model = currentModel;
-        }
-        const result = await fetch('/api/sd/models', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD WebUI returned an error.');
-        }
-        const upscalers = await getVladRemoteUpscalers();
-        if (Array.isArray(upscalers) && upscalers.length > 0) {
-            $('#sd_hr_upscaler').empty();
-            for (const upscaler of upscalers) {
-                const option = document.createElement('option');
-                option.innerText = upscaler;
-                option.value = upscaler;
-                option.selected = upscaler === extension_settings.sd.hr_upscaler;
-                $('#sd_hr_upscaler').append(option);
-            }
-        }
-        return await result.json();
-    } catch (error) {
-        return [];
-    }
-}
-async function loadNovelModels() {
-    return [
-        {
-            value: 'nai-diffusion-4-5-full',
-            text: 'NAI Diffusion Anime V4.5 (Full)',
-        },
-        {
-            value: 'nai-diffusion-4-5-curated',
-            text: 'NAI Diffusion Anime V4.5 (Curated)',
-        },
-        {
-            value: 'nai-diffusion-4-full',
-            text: 'NAI Diffusion Anime V4 (Full)',
-        },
-        {
-            value: 'nai-diffusion-4-curated-preview',
-            text: 'NAI Diffusion Anime V4 (Curated)',
-        },
-        {
-            value: 'nai-diffusion-3',
-            text: 'NAI Diffusion Anime V3',
-        },
-        {
-            value: 'nai-diffusion-2',
-            text: 'NAI Diffusion Anime V2',
-        },
-        {
-            value: 'nai-diffusion-furry-3',
-            text: 'NAI Diffusion Furry V3',
-        },
-    ];
-}
-async function loadGoogleModels() {
-    return [
-        'imagen-4.0-generate-001',
-        'imagen-4.0-ultra-generate-001',
-        'imagen-4.0-fast-generate-001',
-        'imagen-4.0-generate-preview-06-06',
-        'imagen-4.0-fast-generate-preview-06-06',
-        'imagen-4.0-ultra-generate-preview-06-06',
-        'imagen-3.0-generate-002',
-        'imagen-3.0-generate-001',
-        'imagen-3.0-fast-generate-001',
-        'imagen-3.0-capability-001',
-        'imagegeneration@006',
-        'imagegeneration@005',
-        'imagegeneration@002',
-        'veo-3.1-generate-preview',
-        'veo-3.1-fast-generate-preview',
-        'veo-3.0-generate-001',
-        'veo-3.0-fast-generate-001',
-        'veo-2.0-generate-001',
-        'veo-2.0-generate-exp',
-        'veo-2.0-generate-preview',
-    ].map(name => ({ value: name, text: name }));
-}
-async function loadZaiModels() {
-    return [
-        { value: 'glm-image', text: 'GLM-Image' },
-        { value: 'cogview-4-250304', text: 'CogView-4' },
-        { value: 'cogvideox-3', text: 'CogVideoX-3' },
-        { value: 'viduq1-text', text: 'Viduq1-Text' },
-    ];
-}
-async function loadOpenRouterModels() {
-    const result = await fetch('/api/openrouter/models/image', {
-        method: 'POST',
-        headers: getRequestHeaders({ omitContentType: true }),
-    });
-    if (result.ok) {
-        return await result.json();
-    }
-    return [];
-}
-function loadNovelSchedulers() {
-    return ['karras', 'native', 'exponential', 'polyexponential'];
-}
-async function loadComfyModels() {
-    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 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]);
-        return [
-            { value: '', text: 'N/A' },
-        ];
-    }
-    if (!extension_settings.sd.comfy_url) {
-        return [];
-    }
-    try {
-        const result = await fetch('/api/sd/comfy/models', {
-            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 [];
-    }
-}
-async function loadSchedulers() {
-    $('#sd_scheduler').empty();
-    let schedulers = [];
-    switch (extension_settings.sd.source) {
-        case sources.extras:
-            schedulers = ['N/A'];
-            break;
-        case sources.horde:
-            schedulers = ['N/A'];
-            break;
-        case sources.auto:
-            schedulers = await getAutoRemoteSchedulers();
-            break;
-        case sources.sdcpp:
-            schedulers = await loadSdcppSchedulers();
-            break;
-        case sources.novel:
-            schedulers = loadNovelSchedulers();
-            break;
-        case sources.vlad:
-            schedulers = ['N/A'];
-            break;
-        case sources.drawthings:
-            schedulers = ['N/A'];
-            break;
-        case sources.openai:
-            schedulers = ['N/A'];
-            break;
-        case sources.aimlapi:
-            schedulers = ['N/A'];
-            break;
-        case sources.togetherai:
-            schedulers = ['N/A'];
-            break;
-        case sources.pollinations:
-            schedulers = ['N/A'];
-            break;
-        case sources.comfy:
-            schedulers = await loadComfySchedulers();
-            break;
-        case sources.stability:
-            schedulers = ['N/A'];
-            break;
-        case sources.huggingface:
-            schedulers = ['N/A'];
-            break;
-        case sources.chutes:
-            schedulers = ['N/A'];
-            break;
-        case sources.electronhub:
-            schedulers = ['N/A'];
-            break;
-        case sources.nanogpt:
-            schedulers = ['N/A'];
-            break;
-        case sources.bfl:
-            schedulers = ['N/A'];
-            break;
-        case sources.falai:
-            schedulers = ['N/A'];
-            break;
-        case sources.xai:
-            schedulers = ['N/A'];
-            break;
-        case sources.google:
-            schedulers = ['N/A'];
-            break;
-        case sources.zai:
-            schedulers = ['N/A'];
-            break;
-        case sources.openrouter:
-            schedulers = ['N/A'];
-            break;
-        case sources.workersai:
-            schedulers = ['N/A'];
-            break;
-    }
-    for (const scheduler of schedulers) {
-        const option = document.createElement('option');
-        option.innerText = scheduler;
-        option.value = scheduler;
-        option.selected = scheduler === extension_settings.sd.scheduler;
-        $('#sd_scheduler').append(option);
-    }
-    if (!extension_settings.sd.scheduler && schedulers.length > 0 && schedulers[0] !== 'N/A') {
-        extension_settings.sd.scheduler = schedulers[0];
-        $('#sd_scheduler').val(extension_settings.sd.scheduler).trigger('change');
-    }
-}
-async function loadComfySchedulers() {
-    if (extension_settings.sd.comfy_type === comfyTypes.runpod_serverless) {
-        return ['N/A'];
-    }
-    if (isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
-        // Do not query /object_info through a cold lazy proxy on page load.
-        return extension_settings.sd.scheduler ? [extension_settings.sd.scheduler] : [];
-    }
-    if (!extension_settings.sd.comfy_url) {
-        return [];
-    }
-    try {
-        const result = await fetch('/api/sd/comfy/schedulers', {
-            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 [];
-    }
-}
-async function loadSdcppSchedulers() {
-    // The sdcpp server does not provide an API for schedulers, so we return the known list.
-    return ['discrete', 'karras', 'exponential', 'ays', 'gits', 'smoothstep', 'sgm_uniform', 'simple', 'kl_optimal', 'lcm'];
-}
-async function loadVaes() {
-    $('#sd_vae').empty();
-    let vaes = [];
-    switch (extension_settings.sd.source) {
-        case sources.extras:
-            vaes = ['N/A'];
-            break;
-        case sources.horde:
-            vaes = ['N/A'];
-            break;
-        case sources.auto:
-            vaes = await loadAutoVaes();
-            break;
-        case sources.sdcpp:
-            vaes = ['N/A'];
-            break;
-        case sources.novel:
-            vaes = ['N/A'];
-            break;
-        case sources.vlad:
-            vaes = ['N/A'];
-            break;
-        case sources.drawthings:
-            vaes = ['N/A'];
-            break;
-        case sources.openai:
-            vaes = ['N/A'];
-            break;
-        case sources.aimlapi:
-            vaes = ['N/A'];
-            break;
-        case sources.togetherai:
-            vaes = ['N/A'];
-            break;
-        case sources.pollinations:
-            vaes = ['N/A'];
-            break;
-        case sources.comfy:
-            vaes = await loadComfyVaes();
-            break;
-        case sources.stability:
-            vaes = ['N/A'];
-            break;
-        case sources.huggingface:
-            vaes = ['N/A'];
-            break;
-        case sources.chutes:
-            vaes = ['N/A'];
-            break;
-        case sources.electronhub:
-            vaes = ['N/A'];
-            break;
-        case sources.nanogpt:
-            vaes = ['N/A'];
-            break;
-        case sources.bfl:
-            vaes = ['N/A'];
-            break;
-        case sources.falai:
-            vaes = ['N/A'];
-            break;
-        case sources.xai:
-            vaes = ['N/A'];
-            break;
-        case sources.google:
-            vaes = ['N/A'];
-            break;
-        case sources.zai:
-            vaes = ['N/A'];
-            break;
-        case sources.openrouter:
-            vaes = ['N/A'];
-            break;
-        case sources.workersai:
-            vaes = ['N/A'];
-            break;
-    }
-    for (const vae of vaes) {
-        const option = document.createElement('option');
-        option.innerText = vae;
-        option.value = vae;
-        option.selected = vae === extension_settings.sd.vae;
-        $('#sd_vae').append(option);
-    }
-    // Snap to the first real entry when nothing is selected OR the saved value
-    // is not offered (otherwise the dropdown displays the first option while
-    // generations keep sending the stale saved value).
-    if (vaes.length > 0 && vaes[0] !== 'N/A' && !vaes.includes(extension_settings.sd.vae)) {
-        extension_settings.sd.vae = vaes[0];
-        $('#sd_vae').val(extension_settings.sd.vae).trigger('change');
-    }
-}
-async function loadAutoVaes() {
-    if (!extension_settings.sd.auto_url) {
-        return ['N/A'];
-    }
-    try {
-        const result = await fetch('/api/sd/vaes', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify(getSdRequestBody()),
-        });
-        if (!result.ok) {
-            throw new Error('SD WebUI returned an error.');
-        }
-        const data = await result.json();
-        Array.isArray(data) && data.unshift(placeholderVae);
-        return data;
-    } catch (error) {
-        return ['N/A'];
-    }
-}
-async function loadComfyVaes() {
-    if (extension_settings.sd.comfy_type === comfyTypes.runpod_serverless) {
-        return ['N/A'];
-    }
-    if (isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
-        // Derive the VAE list from the catalog's download manifests (dest under
-        // vae/) instead of querying the pod, which may be cold.
-        const vaes = getRunpodCatalog()
-            .flatMap(m => parseRunpodFiles(m.downloads))
-            .filter(f => /^vae\//i.test(f.dest))
-            .map(f => f.dest.split('/').pop());
-        return [...new Set(vaes)];
-    }
-    if (!extension_settings.sd.comfy_url) {
-        return [];
-    }
-    try {
-        const result = await fetch('/api/sd/comfy/vaes', {
-            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 [];
-    }
-}
-async function loadComfyWorkflows() {
-    try {
-        $('#sd_comfy_workflow').empty();
-        const result = await fetch('/api/sd/comfy/workflows', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify({
-                url: extension_settings.sd.comfy_url,
-            }),
-        });
-        if (!result.ok) {
-            throw new Error('ComfyUI returned an error.');
-        }
-        const workflows = await result.json();
-        for (const workflow of workflows) {
-            const option = document.createElement('option');
-            option.innerText = workflow;
-            option.value = workflow;
-            option.selected = workflow === extension_settings.sd.comfy_workflow;
-            $('#sd_comfy_workflow').append(option);
-        }
-    } catch (error) {
-        console.error(`Could not load ComfyUI workflows: ${error.message}`);
-    }
-}
-function getGenerationType(prompt) {
-    // Custom wand entries use the trigger convention 'custom_<id>' and bypass
-    // the multimodal/free_extend transforms applied to the built-in triggers.
-    const trimmedPrompt = String(prompt).trim();
-    if (Array.isArray(extension_settings.sd.custom_entries)) {
-        const customEntry = extension_settings.sd.custom_entries.find(e => ('custom_' + e.id) === trimmedPrompt);
-        if (customEntry) {
-            return generationMode.CUSTOM;
-        }
-    }
-    let mode = generationMode.FREE;
-    for (const [key, values] of Object.entries(triggerWords)) {
-        for (const value of values) {
-            if (value.toLowerCase() === prompt.toLowerCase().trim()) {
-                mode = Number(key);
-                break;
-            }
-        }
-    }
-    if (extension_settings.sd.multimodal_captioning && multimodalMap[mode] !== undefined) {
-        mode = multimodalMap[mode];
-    }
-    if (mode === generationMode.FREE && extension_settings.sd.free_extend) {
-        mode = generationMode.FREE_EXTENDED;
-    }
-    return mode;
-}
-function getQuietPrompt(mode, trigger) {
-    if (mode === generationMode.CUSTOM) {
-        const entry = Array.isArray(extension_settings.sd.custom_entries)
-            ? extension_settings.sd.custom_entries.find(e => ('custom_' + e.id) === String(trigger).trim())
-            : undefined;
-        return entry ? entry.prompt : trigger;
-    }
-    if (mode === generationMode.FREE) {
-        return trigger;
-    }
-    return stringFormat(extension_settings.sd.prompts[mode], trigger);
-}
-/**
- * Sanitizes generated prompt for image generation.
- * @param {string} str String to process
- * @returns {string} Processed reply
- */
-function processReply(str) {
-    if (!str) {
-        return '';
-    }
-    if (extension_settings.sd.minimal_prompt_processing) {
-        // Minimal prompt processing
-        // JSON and similar should be preserved
-        str = str.normalize('NFD');
-        str = str.replace(/\s+/g, ' '); // Collapse multiple whitespaces into one
-        str = str.trim();
-        return str;
-    }
-    str = str.replaceAll('"', '');
-    str = str.replaceAll('“', '');
-    str = str.replaceAll('\n', ', ');
-    str = str.normalize('NFD');
-    // Strip out non-alphanumeric characters barring model syntax exceptions
-    str = str.replace(/[^a-zA-Z0-9.,:_(){}<>[\]/\-'|#]+/g, ' ');
-    str = str.replace(/\s+/g, ' '); // Collapse multiple whitespaces into one
-    str = str.trim();
-    str = str
-        .split(',') // list split by commas
-        .map(x => x.trim()) // trim each entry
-        .filter(x => x) // remove empty entries
-        .join(', '); // join it back with proper spacing
-    return str;
-}
-function getRawLastMessage() {
-    const getLastUsableMessage = () => {
-        for (const message of context.chat.slice().reverse()) {
-            if (message.is_system) {
-                continue;
-            }
-            return {
-                mes: message.mes,
-                original_avatar: message.original_avatar,
-            };
-        }
-        toastr.warning('No usable messages found.', 'Image Generation');
-        throw new Error('No usable messages found.');
-    };
-    const context = getContext();
-    const lastMessage = getLastUsableMessage();
-    const character = context.groupId
-        ? context.characters.find(c => c.avatar === lastMessage.original_avatar)
-        : context.characters[context.characterId];
-    if (!character) {
-        console.debug('Character not found, using raw message.');
-        return processReply(lastMessage.mes);
-    }
-    return `((${processReply(lastMessage.mes)})), (${processReply(character.scenario)}:0.7), (${processReply(character.description)}:0.5)`;
-}
-/**
- * Ensure that the selected option exists in the dropdown.
- * @param {string} setting Setting key
- * @param {string} selector Dropdown selector
- * @returns {void}
- */
-function ensureSelectionExists(setting, selector) {
-    /** @type {HTMLSelectElement} */
-    const selectElement = document.querySelector(selector);
-    if (!selectElement) {
-        return;
-    }
-    const options = Array.from(selectElement.options);
-    const value = extension_settings.sd[setting];
-    if (selectElement.selectedOptions.length && !options.some(option => option.value === value)) {
-        extension_settings.sd[setting] = selectElement.selectedOptions[0].value;
-    }
-}
-/**
- * Generates an image based on the given trigger word.
- * @param {string} initiator The initiator of the image generation
- * @param {Record<string, object>} args Command arguments
- * @param {string} trigger Subject trigger word
- * @param {string} [message] Chat message
- * @param {function} [callback] Callback function
- * @returns {Promise<string|undefined>} Image path
- * @throws {Error} If the prompt or image generation fails
- */
-async function generatePicture(initiator, args, trigger, message, callback) {
-    if (!trigger || trigger.trim().length === 0) {
-        console.log('Trigger word empty, aborting');
-        return;
-    }
-    if (!isValidState()) {
-        toastr.warning('Image generation is not available. Check your settings and try again.');
-        return;
-    }
-    ensureSelectionExists('sampler', '#sd_sampler');
-    ensureSelectionExists('model', '#sd_model');
-    trigger = trigger.trim();
-    const generationType = getGenerationType(trigger);
-    const generationTypeKey = Object.keys(generationMode).find(key => generationMode[key] === generationType);
-    console.log(`Image generation mode ${generationTypeKey} triggered with "${trigger}"`);
-    const quietPrompt = getQuietPrompt(generationType, trigger);
-    const context = getContext();
-    let characterName = context.groupId
-        ? context.groups[Object.keys(context.groups).filter(x => context.groups[x].id === context.groupId)[0]]?.id?.toString()
-        : context.characters[context.characterId]?.name;
-    if (generationType === generationMode.BACKGROUND) {
-        const callbackOriginal = callback;
-        callback = async function (prompt, imagePath, generationType, _negativePromptPrefix, _initiator, prefixedPrompt, format) {
-            const imgUrl = `url("${encodeURI(imagePath)}")`;
-            await eventSource.emit(event_types.FORCE_SET_BACKGROUND, { url: imgUrl, path: imagePath });
-            if (typeof callbackOriginal === 'function') {
-                await callbackOriginal(prompt, imagePath, generationType, negativePromptPrefix, initiator, prefixedPrompt, format);
-            } else {
-                await sendMessage(prompt, imagePath, generationType, negativePromptPrefix, initiator, prefixedPrompt, format);
-            }
-        };
-    }
-    if (isTrueBoolean(args?.quiet)) {
-        callback = () => { };
-    }
-    if (isFalseBoolean(args?.gallery)) {
-        characterName = '';
-    }
-    const dimensions = setTypeSpecificDimensions(generationType);
-    const abortController = new AbortController();
-    let negativePromptPrefix = args?.negative || '';
-    let imagePath = '';
-    const stopListener = () => abortController.abort('Aborted by user');
-    let loaderHandle = ActionLoaderHandle.EMPTY;
-    try {
-        const combineNegatives = (prefix) => { negativePromptPrefix = combinePrefixes(negativePromptPrefix, prefix); };
-        // Each new generation picks its own reference image (swipes reuse the last one).
-        pendingReferenceImage = null;
-        // generate the text prompt for the image
-        let prompt = await getPrompt(generationType, message, trigger, quietPrompt, combineNegatives);
-        console.log('Processed image prompt:', prompt);
-        // Extension hook for prompt processing
-        const eventData = { prompt, generationType, message, trigger };
-        await eventSource.emit(event_types.SD_PROMPT_PROCESSING, eventData);
-        prompt = eventData.prompt; // Allow extensions to modify the prompt
-        if (typeof args?._abortController?.addEventListener === 'function') {
-            args._abortController.addEventListener('abort', stopListener);
-        }
-        // Show non-blocking stoppable toast for this generation
-        loaderHandle = loader.show({
-            blocking: false,
-            slug: `${MODULE_NAME}-image-generation`,
-            title: t`Image Generation`,
-            message: t`Generating an image...`,
-            onStop: stopListener,
-        });
-        // generate the image
-        imagePath = await sendGenerationRequest(generationType, prompt, negativePromptPrefix, characterName, callback, initiator, abortController.signal);
-    } catch (err) {
-        // Check if this was an intentional abort by user
-        if (abortController.signal.aborted) {
-            console.log('SD: Image generation aborted by user');
-            toastr.info('Image generation stopped.', 'Image Generation');
-            return;
-        }
-        console.trace(err);
-        // errors here are most likely due to text generation failure
-        // sendGenerationRequest mostly deals with its own errors
-        const reason = err.error?.message || err.message || 'Unknown error';
-        const errorText = 'SD prompt text generation failed. ' + reason;
-        toastr.error(errorText, 'Image Generation');
-        throw new Error(errorText);
-    } finally {
-        restoreOriginalDimensions(dimensions);
-        await loaderHandle.hide();
-    }
-    return imagePath;
-}
-/**
- * Adjusts image generation dimensions based on the generation type and/or previous media attachment.
- * @param {number} generationType The type of image generation to perform, used to determine dimension adjustments
- * @param {MediaAttachment} [mediaAttachment] Media attachment to base dimension adjustments on
- * @returns {{height: number, width: number}} Previous dimensions before modification
- */
-function setTypeSpecificDimensions(generationType, mediaAttachment = null) {
-    const prevSDHeight = extension_settings.sd.height;
-    const prevSDWidth = extension_settings.sd.width;
-    const aspectRatio = extension_settings.sd.width / extension_settings.sd.height;
-    // 1. If there's a media attachment, match its previous dimensions
-    // 2. Face images are always portrait (pun intended) - increase height if needed
-    // 3. Background images are always landscape - increase width if needed
-    if (Number.isInteger(mediaAttachment?.width) && Number.isInteger(mediaAttachment?.height)) {
-        extension_settings.sd.width = mediaAttachment.width;
-        extension_settings.sd.height = mediaAttachment.height;
-    } else if ((generationType === generationMode.FACE || generationType === generationMode.FACE_MULTIMODAL) && aspectRatio >= 1) {
-        // Round to nearest multiple of 64
-        extension_settings.sd.height = Math.round(extension_settings.sd.width * 1.5 / 64) * 64;
-    } else if (generationType === generationMode.BACKGROUND && aspectRatio <= 1) {
-        // Round to nearest multiple of 64
-        extension_settings.sd.width = Math.round(extension_settings.sd.height * 1.8 / 64) * 64;
-    }
-    if (extension_settings.sd.snap) {
-        // Force to use roughly the same pixel count as before rescaling
-        const prevPixelCount = prevSDHeight * prevSDWidth;
-        const newPixelCount = extension_settings.sd.height * extension_settings.sd.width;
-        if (prevPixelCount !== newPixelCount) {
-            const ratio = Math.sqrt(prevPixelCount / newPixelCount);
-            extension_settings.sd.height = Math.round(extension_settings.sd.height * ratio / 64) * 64;
-            extension_settings.sd.width = Math.round(extension_settings.sd.width * ratio / 64) * 64;
-            console.log(`Pixel counts after rescaling: ${prevPixelCount} -> ${newPixelCount} (ratio: ${ratio})`);
-            const resolution = resolutionOptions[getClosestKnownResolution()];
-            if (resolution) {
-                extension_settings.sd.height = resolution.height;
-                extension_settings.sd.width = resolution.width;
-                console.log('Snap to resolution', JSON.stringify(resolution));
-            } else {
-                console.warn('Snap to resolution failed, using custom dimensions');
-            }
-        }
-    }
-    return { height: prevSDHeight, width: prevSDWidth };
-}
-/**
- * Restores the original image generation dimensions after generation is complete.
- * @param {{height: number, width: number}} savedParams The original dimensions to restore
- */
-function restoreOriginalDimensions(savedParams) {
-    extension_settings.sd.height = savedParams.height;
-    extension_settings.sd.width = savedParams.width;
-}
-/**
- * Generates a prompt for image generation.
- * @param {number} generationType The type of image generation to perform.
- * @param {string} message A message text to use for the image generation.
- * @param {string} trigger A trigger string to use for the image generation.
- * @param {string} quietPrompt A quiet prompt to use for the image generation.
- * @param {function} combineNegatives A function that combines the negative prompt with other prompts.
- * @returns {Promise<string>} - A promise that resolves when the prompt generation completes.
- */
-async function getPrompt(generationType, message, trigger, quietPrompt, combineNegatives) {
-    let prompt;
-    console.log('getPrompt: Generation mode', generationType, 'triggered with', trigger);
-    switch (generationType) {
-        case generationMode.RAW_LAST:
-            prompt = message || getRawLastMessage();
-            break;
-        case generationMode.FREE:
-            prompt = generateFreeModePrompt(trigger.trim(), combineNegatives);
-            break;
-        case generationMode.FACE_MULTIMODAL:
-        case generationMode.CHARACTER_MULTIMODAL:
-        case generationMode.USER_MULTIMODAL:
-            prompt = await generateMultimodalPrompt(generationType, quietPrompt);
-            break;
-        default:
-            prompt = await generatePrompt(quietPrompt);
-            break;
-    }
-    if (generationType === generationMode.FREE_EXTENDED) {
-        prompt = generateFreeModePrompt(prompt.trim(), combineNegatives);
-    }
-    if (generationType !== generationMode.FREE) {
-        prompt = await refinePrompt(prompt);
-    }
-    return prompt;
-}
-/**
- * Generates a free prompt with a character-specific prompt prefix support.
- * @param {string} trigger - The prompt to use for the image generation.
- * @param {function} combineNegatives - A function that combines the negative prompt with other prompts.
- * @returns {string}
- */
-function generateFreeModePrompt(trigger, combineNegatives) {
-    return trigger
-        .replace(/^char(\s|,)|{{charPrefix}}/gi, (_, suffix) => {
-            const getLastCharacterKey = () => {
-                if (typeof this_chid !== 'undefined') {
-                    return getCharaFilename(this_chid);
-                }
-                const context = getContext();
-                for (let i = context.chat.length - 1; i >= 0; i--) {
-                    const message = context.chat[i];
-                    if (!message.is_user && !message.is_system && typeof message.original_avatar === 'string') {
-                        return message.original_avatar.replace(/\.[^/.]+$/, '');
-                    }
-                }
-                return '';
-            };
-            const key = getLastCharacterKey();
-            const value = (extension_settings.sd.character_prompts[key] || '').trim();
-            const negativeValue = (extension_settings.sd.character_negative_prompts[key] || '').trim();
-            typeof combineNegatives === 'function' && negativeValue ? combineNegatives(negativeValue) : void 0;
-            return value ? combinePrefixes(value, (suffix || '')) : '';
-        });
-}
-/**
- * Generates a prompt using multimodal captioning.
- * @param {number} generationType - The type of image generation to perform.
- * @param {string} quietPrompt - The prompt to use for the image generation.
- */
-async function generateMultimodalPrompt(generationType, quietPrompt) {
-    let avatarUrl;
-    if (generationType === generationMode.USER_MULTIMODAL) {
-        avatarUrl = getUserAvatarUrl();
-    }
-    if (generationType === generationMode.CHARACTER_MULTIMODAL || generationType === generationMode.FACE_MULTIMODAL) {
-        avatarUrl = getCharacterAvatarUrl();
-    }
-    try {
-        const toast = toastr.info('Generating multimodal caption...', 'Image Generation');
-        const response = await fetch(avatarUrl);
-        if (!response.ok) {
-            throw new Error('Could not fetch avatar image.');
-        }
-        const avatarBlob = await response.blob();
-        const avatarBase64 = await getBase64Async(avatarBlob);
-        const caption = await getMultimodalCaption(avatarBase64, quietPrompt);
-        toastr.clear(toast);
-        if (!caption) {
-            throw new Error('No caption returned from the API.');
-        }
-        return caption;
-    } catch (error) {
-        console.error(error);
-        toastr.error('Multimodal captioning failed. Please try again.', 'Image Generation');
-        throw new Error('Multimodal captioning failed.');
-    }
-}
-function getCharacterAvatarUrl() {
-    const context = getContext();
-    if (context.groupId) {
-        const groupMembers = context.groups.find(x => x.id === context.groupId)?.members;
-        const lastMessageAvatar = context.chat?.filter(x => !x.is_system && !x.is_user)?.slice(-1)[0]?.original_avatar;
-        const randomMemberAvatar = Array.isArray(groupMembers) ? groupMembers[Math.floor(Math.random() * groupMembers.length)] : null;
-        const avatarToUse = lastMessageAvatar || randomMemberAvatar;
-        return formatCharacterAvatar(avatarToUse);
-    } else {
-        return getCharacterAvatar(context.characterId);
-    }
-}
-function getUserAvatarUrl() {
-    return getUserAvatar(user_avatar);
-}
-/**
- * Generates a prompt using the main LLM API.
- * @param {string} quietPrompt - The prompt to use for the image generation.
- * @returns {Promise<string>} - A promise that resolves when the prompt generation completes.
- */
-async function generatePrompt(quietPrompt) {
-    const toast = toastr.info('Generating image prompt with an LLM...', 'Image Generation');
-    const profileId = extension_settings.sd.prompt_generation_profile;
-    let reply;
-    // When the workflow uses a reference image and there is more than one to choose
-    // from, have the same LLM request return the selection along with the prompt.
-    const refCandidates = await getEligibleReferenceImages();
-    if (refCandidates.length === 1) {
-        pendingReferenceImage = refCandidates[0];
-    }
-    const combineReferenceSelection = refCandidates.length > 1;
-    const effectiveQuietPrompt = combineReferenceSelection
-        ? quietPrompt + '\n' + buildReferenceSelectionAddendum(refCandidates)
-        : quietPrompt;
-    try {
-        reply = profileId
-            ? await withConnectionProfile(profileId, () => generateQuietPrompt({ quietPrompt: effectiveQuietPrompt }))
-            : await generateQuietPrompt({ quietPrompt: effectiveQuietPrompt });
-    } finally {
-        toastr.clear(toast);
-    }
-    if (combineReferenceSelection) {
-        const { cleaned, selected } = extractReferenceSelection(String(reply ?? ''), refCandidates);
-        reply = cleaned;
-        // No/invalid selection -> leave unset; the workflow builder retries with a dedicated call.
-        pendingReferenceImage = selected;
-        console.log('SD: reference image selected with the image prompt:', selected?.tag ?? '(none)');
-    }
-    const processedReply = processReply(reply);
-    if (!processedReply) {
-        toastr.error('Prompt generation produced no text. Make sure you\'re using a valid instruct template and try again', 'Image Generation');
-        throw new Error('Prompt generation failed.');
-    }
-    return processedReply;
-}
-/**
- * Runs a callback with a specific Connection Manager profile temporarily active,
- * then restores the previously active profile. This lets the image prompt be
- * generated by the chosen LLM *with the full chat context* (via generateQuietPrompt),
- * instead of a context-free one-off request.
- *
- * The switch is only performed when a real connection profile is currently active
- * (so it can be reliably restored). When no profile is active — i.e. the user drives
- * the API panel manually — switching to a profile could not be undone without
- * clobbering those manual settings, so we leave the active model in place and warn once.
- *
- * @param {string} targetProfileId Profile to activate for the duration of the callback.
- * @param {() => Promise<any>} callback Work to run while the target profile is active.
- * @returns {Promise<any>} The callback's result.
- */
-async function withConnectionProfile(targetProfileId, callback) {
-    const select = /** @type {HTMLSelectElement} */ (document.getElementById('connection_profiles'));
-    const connectionManager = extension_settings.connectionManager;
-    const currentProfileId = connectionManager?.selectedProfile;
-    const canSwitch = !!select
-        && !!connectionManager
-        && Array.isArray(connectionManager.profiles)
-        && connectionManager.profiles.some(p => p.id === targetProfileId)
-        && Array.from(select.options).some(o => o.value === targetProfileId)
-        && !!currentProfileId // a real profile is active, so it can be restored afterwards
-        && currentProfileId !== targetProfileId;
-    if (!canSwitch) {
-        // Selected but no base profile to restore from -> use the active model and warn once.
-        if (targetProfileId && !currentProfileId && !promptProfileWarnedNoBaseProfile) {
-            promptProfileWarnedNoBaseProfile = true;
-            toastr.info('The image-prompt LLM profile is only applied while a connection profile is active (so the original can be restored). Using the current model.', 'Image Generation');
-        }
-        return await callback();
-    }
-    const switchToProfile = async (profileId) => {
-        const loaded = new Promise(resolve => eventSource.once(event_types.CONNECTION_PROFILE_LOADED, resolve));
-        const index = Array.from(select.options).findIndex(o => o.value === profileId);
-        select.selectedIndex = index >= 0 ? index : 0;
-        select.dispatchEvent(new Event('change'));
-        // Wait for the profile's commands to finish applying (don't hang forever if the event never fires).
-        await Promise.race([loaded, delay(10000)]);
-        // Applying a profile reconnects the API, which is asynchronous. Generating before the
-        // connection is re-established fails instantly, so wait for it to come back up
-        // (mirrors the built-in /profile command). rejectOnTimeout:false -> proceed anyway after the timeout.
-        await waitUntilCondition(() => online_status !== 'no_connection', 10000, 100, { rejectOnTimeout: false });
-    };
-    // Background image-prompt work must not disturb foreground features that follow the user's
-    // active connection profile (notably text prompt-cache keepalives).
-    await eventSource.emit(event_types.CONNECTION_PROFILE_TEMPORARY_STARTED);
-    try {
-        await switchToProfile(targetProfileId);
-        return await callback();
-    } finally {
-        try {
-            await switchToProfile(currentProfileId);
-        } catch (err) {
-            console.error('SD: failed to restore the previous connection profile after image-prompt generation', err);
-        } finally {
-            await eventSource.emit(event_types.CONNECTION_PROFILE_TEMPORARY_ENDED);
-        }
-    }
-}
-/**
- * Sends a request to image generation endpoint and processes the result.
- * @param {number} generationType Type of image generation
- * @param {string} prompt Prompt to be used for image generation
- * @param {string} additionalNegativePrefix Additional negative prompt to be used for image generation
- * @param {string} characterName Name of the character
- * @param {function} callback Callback function to be called after image generation
- * @param {string} initiator The initiator of the image generation
- * @param {AbortSignal} signal Abort signal to cancel the request
- * @returns
- */
-async function sendGenerationRequest(generationType, prompt, additionalNegativePrefix, characterName, callback, initiator, signal) {
-    const noCharPrefix = [generationMode.FREE, generationMode.BACKGROUND, generationMode.USER, generationMode.USER_MULTIMODAL, generationMode.FREE_EXTENDED];
-    const isCharChat = this_chid !== undefined && !selected_group;
-    const ignoreNoCharForSwipe = initiator === initiators.swipe && isCharChat;
-    const skipCharPrefix = !ignoreNoCharForSwipe && noCharPrefix.includes(generationType);
-    /**
-     * Performs a single image generation attempt against the live extension_settings.sd config.
-     * Reads settings live so it can be retried after applying a fallback preset.
-     * @param {AbortSignal} attemptSignal Abort signal to cancel the request.
-     * @returns {Promise<{result: {format: string, data: string}, prefixedPrompt: string}>}
-     * @throws {Error} On failure or when the endpoint returns no image data.
-     */
-    async function attemptImageGeneration(attemptSignal) {
-        const prefix = skipCharPrefix
-            ? extension_settings.sd.prompt_prefix
-            : combinePrefixes(extension_settings.sd.prompt_prefix, getCharacterPrefix());
-        const negativePrefix = skipCharPrefix
-            ? extension_settings.sd.negative_prompt
-            : combinePrefixes(extension_settings.sd.negative_prompt, getCharacterNegativePrefix());
-        const prefixedPrompt = substituteParams(combinePrefixes(prefix, prompt, '{prompt}'));
-        const negativePrompt = substituteParams(combinePrefixes(additionalNegativePrefix, negativePrefix));
-        let result = { format: '', data: '' };
-        switch (extension_settings.sd.source) {
-            case sources.extras:
-                result = await generateExtrasImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.horde:
-                result = await generateHordeImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.vlad:
-                result = await generateAutoImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.drawthings:
-                result = await generateDrawthingsImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.auto:
-                result = await generateAutoImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.sdcpp:
-                result = await generateSdcppImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.novel:
-                result = await generateNovelImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.openai:
-                result = await generateOpenAiImage(prefixedPrompt, attemptSignal);
-                break;
-            case sources.aimlapi:
-                result = await generateAimlapiImage(prefixedPrompt, attemptSignal);
-                break;
-            case sources.comfy:
-                switch (extension_settings.sd.comfy_type) {
-                    case comfyTypes.runpod_serverless:
-                        result = await generateComfyRunPodImage(prefixedPrompt, negativePrompt, attemptSignal);
-                        break;
-                    case comfyTypes.standard:
-                        result = await generateComfyImage(prefixedPrompt, negativePrompt, attemptSignal);
-                        break;
-                    default:
-                        throw new Error('Unknown comfyUI server type.');
-                }
-                break;
-            case sources.togetherai:
-                result = await generateTogetherAIImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.pollinations:
-                result = await generatePollinationsImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.stability:
-                result = await generateStabilityImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.huggingface:
-                result = await generateHuggingFaceImage(prefixedPrompt, attemptSignal);
-                break;
-            case sources.chutes:
-                result = await generateChutesImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.electronhub:
-                result = await generateElectronHubImage(prefixedPrompt, attemptSignal);
-                break;
-            case sources.nanogpt:
-                result = await generateNanoGPTImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.bfl:
-                result = await generateBflImage(prefixedPrompt, attemptSignal);
-                break;
-            case sources.falai:
-                result = await generateFalaiImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.xai:
-                result = await generateXAIImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.google:
-                result = await generateGoogleImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-            case sources.zai:
-                result = await generateZaiImage(prefixedPrompt, attemptSignal);
-                break;
-            case sources.openrouter:
-                result = await generateOpenRouterImage(prefixedPrompt, attemptSignal);
-                break;
-            case sources.workersai:
-                result = await generateWorkersAIImage(prefixedPrompt, negativePrompt, attemptSignal);
-                break;
-        }
-        if (!result.data) {
-            throw new Error('Endpoint did not return image data.');
-        }
-        return { result, prefixedPrompt };
-    }
-    const currentChatId = getCurrentChatId();
-    const fallbackChain = extension_settings.sd.settings_fallback_enabled ? getConfiguredPresetChain() : [];
-    let genOutput;
-    if (fallbackChain.length > 0) {
-        // Chain mode: try every preset in order. Locally-hosted backends are probed
-        // first so a powered-off server is skipped after ~1.5s instead of stalling
-        // the attempt. The live settings are restored afterward either way.
-        const restore = snapshotSdSettings();
-        let lastError = new Error('No provider in the fallback chain was reachable.');
-        try {
-            for (const entry of fallbackChain) {
-                applySdSettingsSnapshot(entry.preset);
-                if (!(await isCurrentSourceReachable())) {
-                    console.warn(`SD: chain entry "${entry.name}" is not reachable, skipping`);
-                    toastr.warning(`Provider "${entry.name}" is not reachable, trying the next one…`, 'Image Generation');
-                    continue;
-                }
-                try {
-                    genOutput = await attemptImageGeneration(signal);
-                    break;
-                } catch (err) {
-                    if (signal?.aborted) {
-                        console.log('SD: Image generation aborted by user');
-                        toastr.info('Image generation stopped.', 'Image Generation');
-                        return;
-                    }
-                    lastError = err;
-                    console.error(`SD: generation with chain entry "${entry.name}" failed`, err);
-                    toastr.warning(`Provider "${entry.name}" failed, trying the next one…`, 'Image Generation');
-                }
-            }
-        } finally {
-            applySdSettingsSnapshot(restore);
-        }
-        if (!genOutput) {
-            toastr.error('Image generation failed for every provider in the fallback chain.' + '\n\n' + String(lastError), 'Image Generation');
-            return;
-        }
-    } else {
-        try {
-            genOutput = await attemptImageGeneration(signal);
-        } catch (err) {
-            // Check if this was an intentional abort by user
-            if (signal?.aborted) {
-                console.log('SD: Image generation aborted by user');
-                toastr.info('Image generation stopped.', 'Image Generation');
-                return;
-            }
-            console.error('Image generation request error: ', err);
-            toastr.error('Image generation failed. Please try again.' + '\n\n' + String(err), 'Image Generation');
-            return;
-        }
-    }
-    const { result, prefixedPrompt } = genOutput;
-    if (currentChatId !== getCurrentChatId()) {
-        console.warn('Chat changed, aborting SD result saving');
-        toastr.warning('Chat changed, generated image discarded.', 'Image Generation');
-        return;
-    }
-    const filename = characterName ? `${characterName}_${humanizedDateTime()}` : humanizedDateTime();
-    const base64Image = await saveBase64AsFile(result.data, characterName, filename, result.format);
-    callback
-        ? await callback(prompt, base64Image, generationType, additionalNegativePrefix, initiator, prefixedPrompt, result.format)
-        : await sendMessage(prompt, base64Image, generationType, additionalNegativePrefix, initiator, prefixedPrompt, result.format);
-    return base64Image;
-}
-/**
- * Generates an image using the TogetherAI API.
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateTogetherAIImage(prompt, negativePrompt, signal) {
-    const result = await fetch('/api/sd/together/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            prompt: prompt,
-            negative_prompt: negativePrompt,
-            model: extension_settings.sd.model,
-            steps: extension_settings.sd.steps,
-            width: extension_settings.sd.width,
-            height: extension_settings.sd.height,
-            seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-        }),
-    });
-    if (result.ok) {
-        return await result.json();
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image using the Pollinations API.
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generatePollinationsImage(prompt, negativePrompt, signal) {
-    const result = await fetch('/api/sd/pollinations/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            prompt: prompt,
-            negative_prompt: negativePrompt,
-            model: extension_settings.sd.model,
-            width: extension_settings.sd.width,
-            height: extension_settings.sd.height,
-            enhance: extension_settings.sd.pollinations_enhance,
-            seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: data?.format, data: data?.image };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an "extras" image using a provided prompt and other settings.
- *
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateExtrasImage(prompt, negativePrompt, signal) {
-    const url = new URL(getApiUrl());
-    url.pathname = '/api/image';
-    const result = await doExtrasFetch(url, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        signal: signal,
-        body: JSON.stringify({
-            prompt: prompt,
-            sampler: extension_settings.sd.sampler,
-            steps: extension_settings.sd.steps,
-            scale: extension_settings.sd.scale,
-            width: extension_settings.sd.width,
-            height: extension_settings.sd.height,
-            negative_prompt: negativePrompt,
-            restore_faces: !!extension_settings.sd.restore_faces,
-            enable_hr: !!extension_settings.sd.enable_hr,
-            karras: !!extension_settings.sd.horde_karras,
-            hr_upscaler: extension_settings.sd.hr_upscaler,
-            hr_scale: extension_settings.sd.hr_scale,
-            denoising_strength: extension_settings.sd.denoising_strength,
-            hr_second_pass_steps: extension_settings.sd.hr_second_pass_steps,
-            seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'jpg', data: data.image };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Gets an aspect ratio for Stability that is the closest to the given width and height.
- * @param {number} width Target width
- * @param {number} height Target height
- * @param {'google'|'stability'|'zai'|'xai'} source Source of the request, used to determine aspect ratio
- * @returns {string} Closest aspect ratio as a string
- */
-function getClosestAspectRatio(width, height, source) {
-    function getAspectRatios() {
-        switch (source) {
-            case 'stability':
-                return {
-                    '16:9': 16 / 9,
-                    '1:1': 1,
-                    '21:9': 21 / 9,
-                    '2:3': 2 / 3,
-                    '3:2': 3 / 2,
-                    '4:5': 4 / 5,
-                    '5:4': 5 / 4,
-                    '9:16': 9 / 16,
-                    '9:21': 9 / 21,
-                };
-            case 'google':
-                return {
-                    '1:1': 1,
-                    '16:9': 16 / 9,
-                    '9:16': 9 / 16,
-                    '4:3': 4 / 3,
-                    '3:4': 3 / 4,
-                };
-            case 'zai':
-                return {
-                    '1:1': 1,
-                    '16:9': 16 / 9,
-                    '9:16': 9 / 16,
-                };
-            case 'xai':
-                return {
-                    '1:1': 1,
-                    '3:4': 3 / 4,
-                    '4:3': 4 / 3,
-                    '9:16': 9 / 16,
-                    '16:9': 16 / 9,
-                    '2:3': 2 / 3,
-                    '3:2': 3 / 2,
-                    '9:19.5': 9 / 19.5,
-                    '19.5:9': 19.5 / 9,
-                    '9:20': 9 / 20,
-                    '20:9': 20 / 9,
-                    '1:2': 1 / 2,
-                    '2:1': 2 / 1,
-                };
-            default:
-                console.warn(`Unknown source "${source}" for aspect ratio calculation.`);
-                return null;
-        }
-    }
-    const aspectRatios = getAspectRatios() || { '1:1': 1 };
-    const aspectRatio = width / height;
-    let closestAspectRatio = Object.keys(aspectRatios)[0];
-    let minDiff = Math.abs(aspectRatio - aspectRatios[closestAspectRatio]);
-    for (const key in aspectRatios) {
-        const diff = Math.abs(aspectRatio - aspectRatios[key]);
-        if (diff < minDiff) {
-            minDiff = diff;
-            closestAspectRatio = key;
-        }
-    }
-    return closestAspectRatio;
-}
-/**
- * Get closest size for Electron Hub
- * @param {number} width - The width of the image
- * @param {number} height - The height of the image
- * @param {string[]} sizes - Available sizes
- * @returns {Promise<string>} - The closest size
- */
-async function getClosestSize(width, height, sizes = []) {
-    const sizesData = [];
-    if (Array.isArray(sizes) && sizes.length > 0) {
-        sizesData.push(...sizes);
-    } else if (extension_settings.sd.source === sources.electronhub) {
-        const response = await fetch('/api/sd/electronhub/sizes', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify({
-                model: extension_settings.sd.model,
-            }),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(text);
-        }
-        const result = await response.json();
-        sizesData.push(...result.sizes);
-    } else {
-        return null;
-    }
-    const targetWidth = Number(width);
-    const targetHeight = Number(height);
-    if (isNaN(targetWidth) || isNaN(targetHeight)) {
-        return null;
-    }
-    const targetAspect = targetWidth / targetHeight;
-    const targetResolution = targetWidth * targetHeight;
-    const closestSize = sizesData.reduce((closest, size) => {
-        if (!size || typeof size !== 'string') {
-            return closest;
-        }
-        const sizeParts = size.split('x');
-        if (sizeParts.length !== 2) {
-            return closest;
-        }
-        const sizeWidth = Number(sizeParts[0]);
-        const sizeHeight = Number(sizeParts[1]);
-        if (isNaN(sizeWidth) || isNaN(sizeHeight)) {
-            return closest;
-        }
-        const aspectDiff = Math.abs((sizeWidth / sizeHeight) - targetAspect) / targetAspect;
-        const resolutionDiff = Math.abs(sizeWidth * sizeHeight - targetResolution) / targetResolution;
-        const diff = aspectDiff + resolutionDiff;
-        return diff < closest.diff ? { size, diff } : closest;
-    }, { size: null, diff: Infinity });
-    const size = closestSize.size;
-    return size;
-}
-/**
- * Generates an image using Stability AI.
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateStabilityImage(prompt, negativePrompt, signal) {
-    const IMAGE_FORMAT = 'png';
-    const PROMPT_LIMIT = 10000;
-    try {
-        const response = await fetch('/api/sd/stability/generate', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            signal: signal,
-            body: JSON.stringify({
-                model: extension_settings.sd.model,
-                payload: {
-                    prompt: prompt.slice(0, PROMPT_LIMIT),
-                    negative_prompt: negativePrompt.slice(0, PROMPT_LIMIT),
-                    aspect_ratio: getClosestAspectRatio(extension_settings.sd.width, extension_settings.sd.height, 'stability'),
-                    seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-                    style_preset: extension_settings.sd.stability_style_preset,
-                    output_format: IMAGE_FORMAT,
-                },
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const base64Image = await response.text();
-        return {
-            format: IMAGE_FORMAT,
-            data: base64Image,
-        };
-    } catch (error) {
-        console.error('Error generating image with Stability AI:', error);
-        throw error;
-    }
-}
-/**
- * Generates a "horde" image using the provided prompt and configuration settings.
- *
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateHordeImage(prompt, negativePrompt, signal) {
-    const result = await fetch('/api/horde/generate-image', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            prompt: prompt,
-            sampler: extension_settings.sd.sampler,
-            steps: extension_settings.sd.steps,
-            scale: extension_settings.sd.scale,
-            width: extension_settings.sd.width,
-            height: extension_settings.sd.height,
-            negative_prompt: negativePrompt,
-            model: extension_settings.sd.model,
-            nsfw: extension_settings.sd.horde_nsfw,
-            restore_faces: !!extension_settings.sd.restore_faces,
-            enable_hr: !!extension_settings.sd.enable_hr,
-            sanitize: !!extension_settings.sd.horde_sanitize,
-            clip_skip: extension_settings.sd.clip_skip,
-            seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.text();
-        return { format: 'webp', data: data };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image in SD WebUI API using the provided prompt and configuration settings.
- *
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateAutoImage(prompt, negativePrompt, signal) {
-    const isValidVae = extension_settings.sd.vae && !['N/A', placeholderVae].includes(extension_settings.sd.vae);
-    let payload = {
-        ...getSdRequestBody(),
-        prompt: prompt,
-        negative_prompt: negativePrompt,
-        sampler_name: extension_settings.sd.sampler,
-        scheduler: extension_settings.sd.scheduler,
-        steps: extension_settings.sd.steps,
-        cfg_scale: extension_settings.sd.scale,
-        width: extension_settings.sd.width,
-        height: extension_settings.sd.height,
-        restore_faces: !!extension_settings.sd.restore_faces,
-        enable_hr: !!extension_settings.sd.enable_hr,
-        hr_upscaler: extension_settings.sd.hr_upscaler,
-        hr_scale: extension_settings.sd.hr_scale,
-        hr_additional_modules: [],
-        denoising_strength: extension_settings.sd.denoising_strength,
-        hr_second_pass_steps: extension_settings.sd.hr_second_pass_steps,
-        seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-        override_settings: {
-            CLIP_stop_at_last_layers: extension_settings.sd.clip_skip,
-            sd_vae: isValidVae ? extension_settings.sd.vae : undefined,
-            forge_additional_modules: isValidVae ? [extension_settings.sd.vae] : undefined, // For SD Forge
-        },
-        override_settings_restore_afterwards: true,
-        clip_skip: extension_settings.sd.clip_skip, // For SD.Next
-        save_images: true,
-        send_images: true,
-        do_not_save_grid: false,
-        do_not_save_samples: false,
-    };
-    // Conditionally add the ADetailer if adetailer_face is enabled
-    if (extension_settings.sd.adetailer_face) {
-        payload = deepMerge(payload, {
-            alwayson_scripts: {
-                ADetailer: {
-                    args: [
-                        true, // ad_enable
-                        true, // skip_img2img
-                        {
-                            'ad_model': 'face_yolov8n.pt',
-                        },
-                    ],
-                },
-            },
-        });
-    }
-    // Make the fetch call with the payload
-    const result = await fetch('/api/sd/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify(payload),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'png', data: data.images[0] };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image using stable-diffusion.cpp server API.
- *
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateSdcppImage(prompt, negativePrompt, signal) {
-    const payload = {
-        url: extension_settings.sd.sdcpp_url,
-        model: extension_settings.sd.model || undefined,
-        prompt: prompt,
-        negative_prompt: negativePrompt,
-        steps: extension_settings.sd.steps,
-        cfg_scale: extension_settings.sd.scale,
-        width: extension_settings.sd.width,
-        height: extension_settings.sd.height,
-        batch_size: 1,
-        seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-    };
-    if (extension_settings.sd.sampler && extension_settings.sd.sampler !== 'N/A') {
-        payload.sampler_name = extension_settings.sd.sampler;
-    }
-    if (extension_settings.sd.scheduler && extension_settings.sd.scheduler !== 'N/A') {
-        payload.scheduler = extension_settings.sd.scheduler;
-    }
-    if (Number.isFinite(extension_settings.sd.clip_skip)) {
-        payload.clip_skip = extension_settings.sd.clip_skip;
-    }
-    const result = await fetch('/api/sd/sdcpp/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify(payload),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'png', data: data.images?.[0] };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image in Drawthings API using the provided prompt and configuration settings.
- *
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateDrawthingsImage(prompt, negativePrompt, signal) {
-    const result = await fetch('/api/sd/drawthings/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            ...getSdRequestBody(),
-            prompt: prompt,
-            negative_prompt: negativePrompt,
-            sampler_name: extension_settings.sd.sampler,
-            steps: extension_settings.sd.steps,
-            cfg_scale: extension_settings.sd.scale,
-            width: extension_settings.sd.width,
-            height: extension_settings.sd.height,
-            restore_faces: !!extension_settings.sd.restore_faces,
-            enable_hr: !!extension_settings.sd.enable_hr,
-            denoising_strength: extension_settings.sd.denoising_strength,
-            clip_skip: extension_settings.sd.clip_skip,
-            upscaler_scale: extension_settings.sd.hr_scale,
-            seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-            // TODO: advanced API parameters: hr, upscaler
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'png', data: data.images[0] };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image in NovelAI API using the provided prompt and configuration settings.
- *
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateNovelImage(prompt, negativePrompt, signal) {
-    const { steps, width, height, sm, sm_dyn } = getNovelParams();
-    const result = await fetch('/api/novelai/generate-image', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            prompt: prompt,
-            model: extension_settings.sd.model,
-            sampler: extension_settings.sd.sampler,
-            scheduler: extension_settings.sd.scheduler,
-            steps: steps,
-            scale: extension_settings.sd.scale,
-            width: width,
-            height: height,
-            negative_prompt: negativePrompt,
-            upscale_ratio: extension_settings.sd.hr_scale,
-            decrisper: extension_settings.sd.novel_decrisper,
-            variety_boost: extension_settings.sd.novel_variety_boost,
-            sm: sm,
-            sm_dyn: sm_dyn,
-            seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.text();
-        return { format: 'png', data: data };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Adjusts extension parameters for NovelAI. Applies Anlas guard if needed.
- * @returns {{steps: number, width: number, height: number, sm: boolean, sm_dyn: boolean}} - A tuple of parameters for NovelAI API.
- */
-function getNovelParams() {
-    let steps = Math.min(extension_settings.sd.steps, 50);
-    let width = extension_settings.sd.width;
-    let height = extension_settings.sd.height;
-    let sm = extension_settings.sd.novel_sm;
-    let sm_dyn = extension_settings.sd.novel_sm_dyn;
-    // If a source was never changed after the scheduler setting was added, we need to set it to 'karras' for compatibility.
-    const schedulers = loadNovelSchedulers();
-    if (!schedulers.includes(extension_settings.sd.scheduler)) {
-        extension_settings.sd.scheduler = 'karras';
-    }
-    if (extension_settings.sd.sampler === 'ddim' ||
-        ['nai-diffusion-4-curated-preview', 'nai-diffusion-4-full'].includes(extension_settings.sd.model)) {
-        sm = false;
-        sm_dyn = false;
-    }
-    // Don't apply Anlas guard if it's disabled.
-    if (!extension_settings.sd.novel_anlas_guard) {
-        return { steps, width, height, sm, sm_dyn };
-    }
-    const MAX_STEPS = 28;
-    const MAX_PIXELS = 1024 * 1024;
-    if (width * height > MAX_PIXELS) {
-        const ratio = Math.sqrt(MAX_PIXELS / (width * height));
-        // Calculate new width and height while maintaining aspect ratio.
-        let newWidth = Math.round(width * ratio);
-        let newHeight = Math.round(height * ratio);
-        // Ensure new dimensions are multiples of 64. If not, reduce accordingly.
-        if (newWidth % 64 !== 0) {
-            newWidth = newWidth - newWidth % 64;
-        }
-        if (newHeight % 64 !== 0) {
-            newHeight = newHeight - newHeight % 64;
-        }
-        // If total pixel count after rounding still exceeds MAX_PIXELS, decrease dimension size by 64 accordingly.
-        while (newWidth * newHeight > MAX_PIXELS) {
-            if (newWidth > newHeight) {
-                newWidth -= 64;
-            } else {
-                newHeight -= 64;
-            }
-        }
-        console.log(`Anlas Guard: Image size (${width}x${height}) > ${MAX_PIXELS}, reducing size to ${newWidth}x${newHeight}`);
-        width = newWidth;
-        height = newHeight;
-    }
-    if (steps > MAX_STEPS) {
-        console.log(`Anlas Guard: Steps (${steps}) > ${MAX_STEPS}, reducing steps to ${MAX_STEPS}`);
-        steps = MAX_STEPS;
-    }
-    return { steps, width, height, sm, sm_dyn };
-}
-/**
- * Generates an image in OpenAI API using the provided prompt and configuration settings.
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateOpenAiImage(prompt, signal) {
-    const dalle2PromptLimit = 1000;
-    const dalle3PromptLimit = 4000;
-    const gptImgPromptLimit = 32000;
-    const isDalle2 = /dall-e-2/.test(extension_settings.sd.model);
-    const isDalle3 = /dall-e-3/.test(extension_settings.sd.model);
-    const isGptImg = /gpt-image-(1|2|latest)/.test(extension_settings.sd.model);
-    const isSora2 = /sora-2/.test(extension_settings.sd.model);
-    if (isDalle2 && prompt.length > dalle2PromptLimit) {
-        prompt = prompt.substring(0, dalle2PromptLimit);
-    }
-    if (isDalle3 && prompt.length > dalle3PromptLimit) {
-        prompt = prompt.substring(0, dalle3PromptLimit);
-    }
-    if (isGptImg && prompt.length > gptImgPromptLimit) {
-        prompt = prompt.substring(0, gptImgPromptLimit);
-    }
-    let width = 1024;
-    let height = 1024;
-    let aspectRatio = extension_settings.sd.width / extension_settings.sd.height;
-    if (isDalle3 && aspectRatio < 1) {
-        height = 1792;
-    }
-    if (isDalle3 && aspectRatio > 1) {
-        width = 1792;
-    }
-    if (isGptImg && aspectRatio < 1) {
-        height = 1536;
-    }
-    if (isGptImg && aspectRatio > 1) {
-        width = 1536;
-    }
-    if (isDalle2 && (extension_settings.sd.width <= 512 && extension_settings.sd.height <= 512)) {
-        width = 512;
-        height = 512;
-    }
-    if (isSora2) {
-        width = aspectRatio >= 1 ? 1280 : 720;
-        height = aspectRatio >= 1 ? 720 : 1280;
-        const videoResult = await fetch('/api/openai/generate-video', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            signal: signal,
-            body: JSON.stringify({
-                prompt: prompt,
-                model: extension_settings.sd.model,
-                size: `${width}x${height}`,
-                seconds: extension_settings.sd.openai_duration,
-            }),
-        });
-        if (!videoResult.ok) {
-            throw new Error(await videoResult.text());
-        }
-        const { format, data } = await videoResult.json();
-        return { format, data };
-    }
-    const result = await fetch('/api/openai/generate-image', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            prompt: prompt,
-            model: extension_settings.sd.model,
-            size: `${width}x${height}`,
-            n: 1,
-            quality: isDalle3 ? extension_settings.sd.openai_quality : (isGptImg ? extension_settings.sd.openai_quality_gpt : undefined),
-            style: isDalle3 ? extension_settings.sd.openai_style : undefined,
-            response_format: isDalle2 || isDalle3 ? 'b64_json' : undefined,
-            moderation: isGptImg ? 'low' : undefined,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'png', data: data?.data[0]?.b64_json };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Universal image generation via AIMLAPI:
- * - Builds the right request body for any model (OpenAI vs SD/Flux/Recraft).
- * - Extracts the URL or base64 response.
- * - If it’s a URL, fetches the image and converts to base64.
- * - Returns { format: 'png', data: '<base64 string>' }, ready for saveBase64AsFile().
- */
-async function generateAimlapiImage(prompt, signal) {
-    const model = extension_settings.sd.model.toLowerCase();
-    const isSdLike =
-        model.startsWith('flux/') ||
-        model.startsWith('stable') ||
-        model === 'recraft-v3' ||
-        model === 'triposr';
-    const body = { prompt, model };
-    if (isSdLike) {
-        body.steps = clamp(extension_settings.sd.steps, 1, 50);
-        body.guidance = clamp(extension_settings.sd.scale, 1.5, 5);
-        body.width = clamp(extension_settings.sd.width, 256, 1440);
-        body.height = clamp(extension_settings.sd.height, 256, 1440);
-        if (extension_settings.sd.seed >= 0) body.seed = extension_settings.sd.seed;
-    } else {
-        body.n = 1;
-        body.size = `${extension_settings.sd.width}x${extension_settings.sd.height}`;
-        body.quality = extension_settings.sd.openai_quality;
-        body.style = extension_settings.sd.openai_style;
-    }
-    const res = await fetch('/api/sd/aimlapi/generate-image', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal,
-        body: JSON.stringify(body),
-    });
-    if (!res.ok) throw new Error(await res.text());
-    const { format, data } = await res.json();
-    return { format, data };
-}
-/**
- * Generates an image in local ComfyUI or serverless runpod using the provided prompt and configuration settings.
- *
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @param {string} basePath - ST server endpoint for the service. '/api/sd/comfy' for local, '/api/sd/comfyrunpod' for serverless.
- * @param {string[]} placeholders - Array of substitutions to apply to the workflow.
- * @param {string} url - The url of the service to call. Passed to ST server.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateComfyImageCommon(prompt, negativePrompt, signal, basePath, placeholders, url) {
-    const workflowResponse = await fetch('/api/sd/comfy/workflow', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        body: JSON.stringify({
-            file_name: extension_settings.sd.comfy_workflow,
-        }),
-    });
-    if (!workflowResponse.ok) {
-        const text = await workflowResponse.text();
-        toastr.error(`Failed to load workflow.\n\n${text}`);
-    }
-    let workflow = (await workflowResponse.json()).replaceAll('"%prompt%"', JSON.stringify(prompt));
-    workflow = workflow.replaceAll('"%negative_prompt%"', JSON.stringify(negativePrompt));
-    const seed = extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : Math.round(Math.random() * Number.MAX_SAFE_INTEGER);
-    workflow = workflow.replaceAll('"%seed%"', JSON.stringify(seed));
-    const denoising_strength = extension_settings.sd.denoising_strength === undefined ? 1.0 : extension_settings.sd.denoising_strength;
-    workflow = workflow.replaceAll('"%denoise%"', JSON.stringify(denoising_strength));
-    const clip_skip = isNaN(extension_settings.sd.clip_skip) ? -1 : -extension_settings.sd.clip_skip;
-    workflow = workflow.replaceAll('"%clip_skip%"', JSON.stringify(clip_skip));
-    placeholders.forEach(ph => {
-        workflow = workflow.replaceAll(`"%${ph}%"`, JSON.stringify(extension_settings.sd[ph]));
-    });
-    (extension_settings.sd.comfy_placeholders ?? []).forEach(ph => {
-        workflow = workflow.replaceAll(`"%${ph.find}%"`, JSON.stringify(substituteParams(ph.replace)));
-    });
-    // Log the workflow before image payloads are substituted in: keeps private
-    // image data (avatars, reference images) out of the console and avoids
-    // scanning multi-megabyte strings (a redaction regex here previously blew
-    // the stack on large reference images).
-    console.log(`{
-        "prompt": ${workflow}
-    }`);
-    if (/%user_avatar%/gi.test(workflow)) {
-        const response = await fetch(getUserAvatarUrl());
-        if (response.ok) {
-            const avatarBlob = await response.blob();
-            const avatarBase64DataUrl = await getBase64Async(avatarBlob);
-            const avatarBase64 = avatarBase64DataUrl.split(',')[1];
-            workflow = workflow.replaceAll('"%user_avatar%"', JSON.stringify(avatarBase64));
-        } else {
-            workflow = workflow.replaceAll('"%user_avatar%"', JSON.stringify(PNG_PIXEL));
-        }
-    }
-    if (/%char_avatar%/gi.test(workflow)) {
-        const response = await fetch(getCharacterAvatarUrl());
-        if (response.ok) {
-            const avatarBlob = await response.blob();
-            const avatarBase64DataUrl = await getBase64Async(avatarBlob);
-            const avatarBase64 = avatarBase64DataUrl.split(',')[1];
-            workflow = workflow.replaceAll('"%char_avatar%"', JSON.stringify(avatarBase64));
-        } else {
-            workflow = workflow.replaceAll('"%char_avatar%"', JSON.stringify(PNG_PIXEL));
-        }
-    }
-    if (REFERENCE_IMAGE_PLACEHOLDER.test(workflow)) {
-        const refImage = await resolveReferenceImageForGeneration(prompt);
-        const refBase64 = (refImage && await fetchReferenceImageBase64(refImage)) || PNG_PIXEL;
-        if (refBase64 !== PNG_PIXEL) {
-            console.log(`SD: workflow reference image: "${refImage.tag}" (${refImage.path})`);
-            toastr.info(`Reference image: ${refImage.description || refImage.tag || refImage.path}`, 'Image Generation');
-        } else {
-            console.warn('SD: workflow uses %reference_image% but no library image was available; sending a transparent pixel');
-        }
-        workflow = workflow.replaceAll('"%reference_image%"', JSON.stringify(refBase64));
-        workflow = workflow.replaceAll('"%reference-image%"', JSON.stringify(refBase64));
-    }
-    const promptResult = await fetch(`${basePath}/generate`, {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            url,
-            prompt: `{
-                "prompt": ${workflow}
-            }`,
-        }),
-    });
-    if (!promptResult.ok) {
-        const text = await promptResult.text();
-        throw new Error(text);
-    }
-    const { format, data } = await promptResult.json();
-    return { format, data };
-}
-/**
- * Generates an image in ComfyUI using the provided prompt and configuration settings.
- *
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateComfyImage(prompt, negativePrompt, signal) {
-    if (isRunpodProxyUrl(extension_settings.sd.comfy_url) && !(await isRunpodReady(SOURCE_PROBE_TIMEOUT_MS))) {
-        throw new Error('RunPod on-demand pod is not ready. Start it with the Warm up control.');
-    }
-    const placeholders = [
-        'model',
-        'vae',
-        'lora',
-        'lora_strength',
-        'sampler',
-        'scheduler',
-        'steps',
-        'scale',
-        'width',
-        'height',
-    ];
-    return generateComfyImageCommon(prompt, negativePrompt, signal, '/api/sd/comfy', placeholders, extension_settings.sd.comfy_url);
-}
-/**
- * Generates an image using ComfyUI through serverless runpod endpoint using the provided prompt and configuration settings.
- *
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateComfyRunPodImage(prompt, negativePrompt, signal) {
-    const placeholders = [
-        'steps',
-        'scale',
-        'width',
-        'height',
-    ];
-    return generateComfyImageCommon(prompt, negativePrompt, signal, '/api/sd/comfyrunpod', placeholders, extension_settings.sd.comfy_runpod_url);
-}
-/**
- * Generates an image in Hugging Face Inference API using the provided prompt and configuration settings (model selected).
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateHuggingFaceImage(prompt, signal) {
-    const result = await fetch('/api/sd/huggingface/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            model: extension_settings.sd.huggingface_model_id,
-            prompt: prompt,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'jpg', data: data.image };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image using the Chutes API.
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateChutesImage(prompt, negativePrompt, signal) {
-    const result = await fetch('/api/sd/chutes/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            model: extension_settings.sd.model,
-            prompt: prompt,
-            negative_prompt: negativePrompt,
-            width: extension_settings.sd.width,
-            height: extension_settings.sd.height,
-            steps: extension_settings.sd.steps,
-            guidance_scale: extension_settings.sd.scale,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'jpg', data: data.image };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image using the Electron Hub API.
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateElectronHubImage(prompt, signal) {
-    const size = await getClosestSize(extension_settings.sd.width, extension_settings.sd.height);
-    const result = await fetch('/api/sd/electronhub/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            model: extension_settings.sd.model,
-            prompt: prompt,
-            size: size,
-            quality: String(extension_settings.sd.electronhub_quality || '').trim() || undefined,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'jpg', data: data.image };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image using the NanoGPT API.
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The instruction used to restrict the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateNanoGPTImage(prompt, negativePrompt, signal) {
-    const result = await fetch('/api/sd/nanogpt/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            model: extension_settings.sd.model,
-            prompt: prompt,
-            negative_prompt: negativePrompt,
-            num_steps: parseInt(extension_settings.sd.steps),
-            scale: parseFloat(extension_settings.sd.scale),
-            width: parseInt(extension_settings.sd.width),
-            height: parseInt(extension_settings.sd.height),
-            resolution: `${extension_settings.sd.width}x${extension_settings.sd.height}`,
-            showExplicitContent: true,
-            nImages: 1,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'jpg', data: data.image };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image using the BFL API.
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateBflImage(prompt, signal) {
-    const result = await fetch('/api/sd/bfl/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            prompt: prompt,
-            model: extension_settings.sd.model,
-            steps: clamp(extension_settings.sd.steps, 1, 50),
-            guidance: clamp(extension_settings.sd.scale, 1.5, 5),
-            width: clamp(extension_settings.sd.width, 256, 1440),
-            height: clamp(extension_settings.sd.height, 256, 1440),
-            prompt_upsampling: !!extension_settings.sd.bfl_upsampling,
-            seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'jpg', data: data.image };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image using the xAI API.
- * @param {string} prompt The main instruction used to guide the image generation.
- * @param {string} _negativePrompt Negative prompt is not used in this API
- * @param {AbortSignal} signal An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} A promise that resolves when the image generation and processing are complete.
- */
-async function generateXAIImage(prompt, _negativePrompt, signal) {
-    let aspectRatio;
-    let resolution;
-    if (/grok-imagine/.test(extension_settings.sd.model)) {
-        const resolutionThreshold = 1296 * 864;
-        const use2kResolution = (extension_settings.sd.width * extension_settings.sd.height) > resolutionThreshold;
-        aspectRatio = getClosestAspectRatio(extension_settings.sd.width, extension_settings.sd.height, 'xai');
-        resolution = use2kResolution ? '2k' : '1k';
-    }
-    const result = await fetch('/api/sd/xai/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            prompt: prompt,
-            model: extension_settings.sd.model,
-            aspect_ratio: aspectRatio,
-            resolution: resolution,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: data.format, data: data.image };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image using the FAL.AI API.
- * @param {string} prompt - The main instruction used to guide the image generation.
- * @param {string} negativePrompt - The negative prompt used to guide the image generation.
- * @param {AbortSignal} signal - An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} - A promise that resolves when the image generation and processing are complete.
- */
-async function generateFalaiImage(prompt, negativePrompt, signal) {
-    const result = await fetch('/api/sd/falai/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            prompt: prompt,
-            negative_prompt: negativePrompt,
-            model: extension_settings.sd.model,
-            steps: clamp(extension_settings.sd.steps, 1, 50),
-            guidance: clamp(extension_settings.sd.scale, 1.5, 5),
-            width: clamp(extension_settings.sd.width, 256, 1440),
-            height: clamp(extension_settings.sd.height, 256, 1440),
-            seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'jpg', data: data.image };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image using the Google Vertex AI API.
- * @param {string} prompt The main instruction used to guide the image generation.
- * @param {string} negativePrompt The instruction used to restrict the image generation.
- * @param {AbortSignal} signal An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} A promise that resolves when the image generation and processing are complete.
- */
-async function generateGoogleImage(prompt, negativePrompt, signal) {
-    const isVeo = /^veo-/.test(extension_settings.sd.model);
-    if (isVeo) {
-        const aspectRatio = extension_settings.sd.width / extension_settings.sd.height;
-        const maxPromptLength = 3000; // 1024 tokens approx.
-        const videoResult = await fetch('/api/google/generate-video', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            signal: signal,
-            body: JSON.stringify({
-                prompt: prompt.slice(0, maxPromptLength),
-                aspect_ratio: aspectRatio >= 1 ? '16:9' : '9:16',
-                seconds: extension_settings.sd.google_duration,
-                negative_prompt: negativePrompt,
-                model: extension_settings.sd.model,
-                api: extension_settings.sd.google_api || 'makersuite',
-                seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-                vertexai_auth_mode: oai_settings.vertexai_auth_mode,
-                vertexai_region: oai_settings.vertexai_region,
-                vertexai_express_project_id: oai_settings.vertexai_express_project_id,
-            }),
-        });
-        if (!videoResult.ok) {
-            const text = await videoResult.text();
-            throw new Error(text);
-        }
-        const data = await videoResult.json();
-        return { format: 'mp4', data: data.video };
-    }
-    const result = await fetch('/api/google/generate-image', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            prompt: prompt,
-            aspect_ratio: getClosestAspectRatio(extension_settings.sd.width, extension_settings.sd.height, 'google'),
-            negative_prompt: negativePrompt,
-            model: extension_settings.sd.model,
-            enhance: extension_settings.sd.google_enhance,
-            api: extension_settings.sd.google_api || 'makersuite',
-            seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-            vertexai_auth_mode: oai_settings.vertexai_auth_mode,
-            vertexai_region: oai_settings.vertexai_region,
-            vertexai_express_project_id: oai_settings.vertexai_express_project_id,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'jpg', data: data.image };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image using the Z.AI API.
- * @param {string} prompt The main instruction used to guide the image generation.
- * @param {AbortSignal} signal An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>} A promise that resolves when the image generation and processing are complete.
- */
-async function generateZaiImage(prompt, signal) {
-    // Video generation models (CogVideoX, Viduq1)
-    if (/(cogvideox|vidu)/.test(extension_settings.sd.model)) {
-        const videoParams = {};
-        if (/cogvideox/.test(extension_settings.sd.model)) {
-            const cogVideoSizes = ['1280x720', '720x1280', '1024x1024', '1080x1920', '2048x1080', '3840x2160'];
-            videoParams.quality = extension_settings.sd.openai_quality === 'hd' ? 'quality' : 'speed';
-            videoParams.size = await getClosestSize(extension_settings.sd.width, extension_settings.sd.height, cogVideoSizes);
-        }
-        if (/vidu/.test(extension_settings.sd.model)) {
-            videoParams.aspect_ratio = getClosestAspectRatio(extension_settings.sd.width, extension_settings.sd.height, 'zai');
-        }
-        const videoResult = await fetch('/api/sd/zai/generate-video', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            signal: signal,
-            body: JSON.stringify({
-                prompt: prompt,
-                model: extension_settings.sd.model,
-                ...videoParams,
-            }),
-        });
-        if (videoResult.ok) {
-            const data = await videoResult.json();
-            return { format: data.format, data: data.video };
-        }
-        const text = await videoResult.text();
-        throw new Error(text);
-    } else {
-        // Image generation models (GLM-Image, CogView)
-        // GLM-Image requires multiples of 32, CogView requires multiples of 16
-        const isGlmImage = /glm-image/.test(extension_settings.sd.model);
-        const multiple = isGlmImage ? 32 : 16;
-        // Round width and height to nearest multiple and clamp to 512-2048 range
-        let width = clamp(Math.round(extension_settings.sd.width / multiple) * multiple, 512, 2048);
-        let height = clamp(Math.round(extension_settings.sd.height / multiple) * multiple, 512, 2048);
-        // CogView has a 2^21px pixel count limit, GLM-Image does not
-        if (!isGlmImage) {
-            while ((width * height) > Math.pow(2, 21)) {
-                if (width >= height) {
-                    width -= multiple;
-                } else {
-                    height -= multiple;
-                }
-            }
-        }
-        const result = await fetch('/api/sd/zai/generate', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            signal: signal,
-            body: JSON.stringify({
-                prompt: prompt,
-                model: extension_settings.sd.model,
-                quality: extension_settings.sd.openai_quality,
-                size: `${width}x${height}`,
-            }),
-        });
-        if (result.ok) {
-            const data = await result.json();
-            return { format: data.format, data: data.image };
-        }
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-/**
- * Generates an image using the OpenRouter API.
- * @param {string} prompt The main instruction used to guide the image generation.
- * @param {AbortSignal} signal An AbortSignal object that can be used to cancel the request.
- * @returns {Promise<{format: string, data: string}>}
- */
-async function generateOpenRouterImage(prompt, signal) {
-    const result = await fetch('/api/openrouter/image/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            model: extension_settings.sd.model,
-            prompt: prompt,
-            aspect_ratio: getClosestAspectRatio(extension_settings.sd.width, extension_settings.sd.height, 'stability'),
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: 'jpg', data: data.image };
-    }
-    const text = await result.text();
-    throw new Error(text);
-}
-async function generateWorkersAIImage(prompt, negativePrompt, signal) {
-    const result = await fetch('/api/sd/workersai/generate', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        signal: signal,
-        body: JSON.stringify({
-            prompt: prompt,
-            negative_prompt: negativePrompt,
-            model: extension_settings.sd.model,
-            width: extension_settings.sd.width,
-            height: extension_settings.sd.height,
-            steps: extension_settings.sd.steps,
-            scale: extension_settings.sd.scale,
-            seed: extension_settings.sd.seed >= 0 ? extension_settings.sd.seed : undefined,
-            account_id: oai_settings.workers_ai_account_id,
-        }),
-    });
-    if (result.ok) {
-        const data = await result.json();
-        return { format: data?.format, data: data?.image };
-    } else {
-        const text = await result.text();
-        throw new Error(text);
-    }
-}
-async function onComfyOpenWorkflowEditorClick() {
-    let workflow = await (await fetch('/api/sd/comfy/workflow', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        body: JSON.stringify({
-            file_name: extension_settings.sd.comfy_workflow,
-        }),
-    })).json();
-    const editorHtml = $(await $.get('scripts/extensions/stable-diffusion/comfyWorkflowEditor.html'));
-    const saveValue = (/** @type {Popup} */ _popup) => {
-        workflow = $('#sd_comfy_workflow_editor_workflow').val().toString();
-        return true;
-    };
-    const popup = new Popup(editorHtml, POPUP_TYPE.CONFIRM, '', { okButton: 'Save', cancelButton: 'Cancel', wide: true, large: true, onClosing: saveValue });
-    const popupResult = popup.show();
-    const checkPlaceholders = () => {
-        workflow = $('#sd_comfy_workflow_editor_workflow').val().toString();
-        $('.sd_comfy_workflow_editor_placeholder_list > li[data-placeholder]').each(function () {
-            const key = this.getAttribute('data-placeholder');
-            const found = workflow.search(`"%${key}%"`) !== -1;
-            this.classList[found ? 'remove' : 'add']('sd_comfy_workflow_editor_not_found');
-        });
-    };
-    $('#sd_comfy_workflow_editor_name').text(extension_settings.sd.comfy_workflow);
-    $('#sd_comfy_workflow_editor_workflow').val(workflow);
-    const addPlaceholderDom = (placeholder) => {
-        const el = $(`
-            <li class="sd_comfy_workflow_editor_not_found" data-placeholder="${placeholder.find}">
-                <span class="sd_comfy_workflow_editor_custom_remove" title="Remove custom placeholder">⊘</span>
-                <span class="sd_comfy_workflow_editor_custom_final">"%${placeholder.find}%"</span><br>
-                <input placeholder="find" title="find" type="text" class="text_pole sd_comfy_workflow_editor_custom_find" value=""><br>
-                <input placeholder="replace" title="replace" type="text" class="text_pole sd_comfy_workflow_editor_custom_replace">
-            </li>
-        `);
-        $('#sd_comfy_workflow_editor_placeholder_list_custom').append(el);
-        el.find('.sd_comfy_workflow_editor_custom_find').val(placeholder.find);
-        el.find('.sd_comfy_workflow_editor_custom_find').on('input', function () {
-            if (!(this instanceof HTMLInputElement)) {
-                return;
-            }
-            placeholder.find = this.value;
-            el.find('.sd_comfy_workflow_editor_custom_final').text(`"%${this.value}%"`);
-            el.attr('data-placeholder', `${this.value}`);
-            checkPlaceholders();
-            saveSettingsDebounced();
-        });
-        el.find('.sd_comfy_workflow_editor_custom_replace').val(placeholder.replace);
-        el.find('.sd_comfy_workflow_editor_custom_replace').on('input', function () {
-            if (!(this instanceof HTMLInputElement)) {
-                return;
-            }
-            placeholder.replace = this.value;
-            saveSettingsDebounced();
-        });
-        el.find('.sd_comfy_workflow_editor_custom_remove').on('click', () => {
-            el.remove();
-            extension_settings.sd.comfy_placeholders.splice(extension_settings.sd.comfy_placeholders.indexOf(placeholder));
-            saveSettingsDebounced();
-        });
-    };
-    $('#sd_comfy_workflow_editor_placeholder_add').on('click', () => {
-        if (!extension_settings.sd.comfy_placeholders) {
-            extension_settings.sd.comfy_placeholders = [];
-        }
-        const placeholder = {
-            find: '',
-            replace: '',
-        };
-        extension_settings.sd.comfy_placeholders.push(placeholder);
-        addPlaceholderDom(placeholder);
-        saveSettingsDebounced();
-    });
-    (extension_settings.sd.comfy_placeholders ?? []).forEach(placeholder => {
-        addPlaceholderDom(placeholder);
-    });
-    checkPlaceholders();
-    $('#sd_comfy_workflow_editor_workflow').on('input', checkPlaceholders);
-    if (await popupResult) {
-        const response = await fetch('/api/sd/comfy/save-workflow', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify({
-                file_name: extension_settings.sd.comfy_workflow,
-                workflow: workflow,
-            }),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            toastr.error(`Failed to save workflow.\n\n${text}`);
-        }
-    }
-}
-async function onComfyNewWorkflowClick() {
-    let name = await callGenericPopup('Workflow name:', POPUP_TYPE.INPUT);
-    if (!name) {
-        return;
-    }
-    if (!String(name).toLowerCase().endsWith('.json')) {
-        name += '.json';
-    }
-    extension_settings.sd.comfy_workflow = name;
-    const response = await fetch('/api/sd/comfy/save-workflow', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        body: JSON.stringify({
-            file_name: extension_settings.sd.comfy_workflow,
-            workflow: '',
-        }),
-    });
-    if (!response.ok) {
-        const text = await response.text();
-        toastr.error(`Failed to save workflow.\n\n${text}`);
-    }
-    saveSettingsDebounced();
-    await loadComfyWorkflows();
-    await delay(200);
-    await onComfyOpenWorkflowEditorClick();
-}
-async function onComfyDeleteWorkflowClick() {
-    const confirm = await callGenericPopup(t`Delete the workflow? This action is irreversible.`, POPUP_TYPE.CONFIRM, '', { okButton: t`Delete`, cancelButton: t`Cancel` });
-    if (!confirm) {
-        return;
-    }
-    const response = await fetch('/api/sd/comfy/delete-workflow', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        body: JSON.stringify({
-            file_name: extension_settings.sd.comfy_workflow,
-        }),
-    });
-    if (!response.ok) {
-        const text = await response.text();
-        toastr.error(`Failed to save workflow.\n\n${text}`);
-    }
-    await loadComfyWorkflows();
-    onComfyWorkflowChange();
-}
-async function onComfyRenameWorkflowClick() {
-    const oldName = extension_settings.sd.comfy_workflow;
-    if (!oldName) {
-        return;
-    }
-    let newName = await callGenericPopup(t`Enter new workflow name:`, POPUP_TYPE.INPUT, oldName);
-    if (!newName) {
-        return;
-    }
-    newName = String(newName).trim();
-    if (!newName.toLowerCase().endsWith('.json')) {
-        newName += '.json';
-    }
-    if (newName === oldName) {
-        return;
-    }
-    const existingWorkflow = Array
-        .from(document.querySelectorAll('#sd_comfy_workflow option'))
-        .find(opt => opt instanceof HTMLOptionElement && opt.value === newName);
-    if (existingWorkflow) {
-        toastr.warning(t`A workflow with that name already exists`);
-        return;
-    }
-    const response = await fetch('/api/sd/comfy/rename-workflow', {
-        method: 'POST',
-        headers: getRequestHeaders(),
-        body: JSON.stringify({
-            old_name: oldName,
-            new_name: newName,
-        }),
-    });
-    if (!response.ok) {
-        const text = await response.text();
-        toastr.error(t`Failed to rename workflow.\n\n${text}`);
-        return;
-    }
-    extension_settings.sd.comfy_workflow = newName;
-    saveSettingsDebounced();
-    await loadComfyWorkflows();
-}
-/**
- * Sends a chat message with the generated image.
- * @param {string} prompt Prompt used for the image generation
- * @param {string} image Base64 encoded image
- * @param {number} generationType Generation type of the image
- * @param {string} additionalNegativePrefix Additional negative prompt used for the image generation
- * @param {string} initiator The initiator of the image generation
- * @param {string} prefixedPrompt Prompt with an attached specific prefix
- * @param {string} format Format of the image (e.g., 'png', 'jpg')
- */
-async function sendMessage(prompt, image, generationType, additionalNegativePrefix, initiator, prefixedPrompt, format) {
-    const context = getContext();
-    const name = context.groupId ? systemUserName : context.name2;
-    const template = extension_settings.sd.prompts[generationMode.MESSAGE] || '{{prompt}}';
-    const messageText = substituteParamsExtended(template, { char: name, prompt: prompt, prefixedPrompt: prefixedPrompt });
-    const mediaType = isVideo(format) ? MEDIA_TYPE.VIDEO : MEDIA_TYPE.IMAGE;
-    /** @type {MediaAttachment} */
-    const mediaAttachment = {
-        url: image,
-        type: mediaType,
-        title: prompt,
-        generation_type: generationType,
-        negative: additionalNegativePrefix,
-        source: MEDIA_SOURCE.GENERATED,
-    };
-    /** @type {ChatMessage} */
-    const message = {
-        name: name,
-        is_user: false,
-        is_system: !getVisibilityByInitiator(initiator),
-        send_date: getMessageTimeStamp(),
-        mes: messageText,
-        extra: {
-            media: [mediaAttachment],
-            media_display: MEDIA_DISPLAY.GALLERY,
-            media_index: 0,
-            inline_image: false,
-            sd_prompt: prompt,
-            sd_prompt_message: messageText,
-        },
-    };
-    context.chat.push(message);
-    const messageId = context.chat.length - 1;
-    await eventSource.emit(event_types.MESSAGE_RECEIVED, messageId, 'extension');
-    context.addOneMessage(message);
-    await eventSource.emit(event_types.CHARACTER_MESSAGE_RENDERED, messageId, 'extension');
-    await context.saveChat();
-    setTimeout(() => context.scrollOnMediaLoad(), debounce_timeout.short);
-}
-/**
- * Gets the visibility of the resulting message based on the initiator.
- * @param {string} initiator Generation initiator
- * @returns {boolean} Is resulting message visible
- */
-function getVisibilityByInitiator(initiator) {
-    switch (initiator) {
-        case initiators.interactive:
-            return !!extension_settings.sd.interactive_visible;
-        case initiators.wand:
-            return !!extension_settings.sd.wand_visible;
-        case initiators.command:
-            return !!extension_settings.sd.command_visible;
-        case initiators.tool:
-            return !!extension_settings.sd.tool_visible;
-        default:
-            return false;
-    }
-}
-async function addSDGenButtons() {
-    const buttonHtml = await renderExtensionTemplateAsync('stable-diffusion', 'button');
-    const dropdownHtml = await renderExtensionTemplateAsync('stable-diffusion', 'dropdown');
-    $('#sd_wand_container').append(buttonHtml);
-    $(document.body).append(dropdownHtml);
-    const button = $('#sd_gen');
-    const dropdown = $('#sd_dropdown');
-    dropdown.hide();
-    let popper = Popper.createPopper(button.get(0), dropdown.get(0), {
-        placement: 'top',
-    });
-    $(document).on('click', '.sd_message_gen', (e) => sdMessageButton($(e.currentTarget), { animate: false }));
-    $(document).on('click', '.mes_edit', rememberImagePromptBeforeEdit);
-    $(document).on('click touchend', function (e) {
-        const target = $(e.target);
-        if (target.is(dropdown) || target.closest(dropdown).length) return;
-        if ((target.is(button) || target.closest(button).length) && !dropdown.is(':visible')) {
-            e.preventDefault();
-            dropdown.fadeIn(animation_duration);
-            popper.update();
-        } else {
-            dropdown.fadeOut(animation_duration);
-        }
-    });
-    renderCustomDropdownEntries();
-    // Use event delegation so dynamically-added custom entries also respond to clicks.
-    $('#sd_dropdown').on('click', 'li[id]', function () {
-        dropdown.fadeOut(animation_duration);
-        const id = $(this).attr('id');
-        const idParamMap = {
-            'sd_you': 'you',
-            'sd_face': 'face',
-            'sd_me': 'me',
-            'sd_world': 'scene',
-            'sd_last': 'last',
-            'sd_raw_last': 'raw_last',
-            'sd_background': 'background',
-        };
-        const param = idParamMap[id];
-        if (param) {
-            console.log('doing /sd ' + param);
-            generatePicture(initiators.wand, {}, param);
-            return;
-        }
-        if (id && id.startsWith('sd_custom_')) {
-            const entryId = id.slice('sd_custom_'.length);
-            console.log('doing /sd custom_' + entryId);
-            generatePicture(initiators.wand, {}, 'custom_' + entryId);
-        }
-    });
-}
-/**
- * Renders the user-defined custom entries into the wand dropdown.
- * Removes any previously rendered custom entries first.
- */
-function renderCustomDropdownEntries() {
-    const list = $('#sd_dropdown ul.list-group');
-    if (!list.length) {
-        return;
-    }
-    list.find('li.sd_custom_entry').remove();
-    const entries = Array.isArray(extension_settings.sd.custom_entries) ? extension_settings.sd.custom_entries : [];
-    for (const entry of entries) {
-        const li = $('<li></li>')
-            .addClass('list-group-item sd_custom_entry')
-            .attr('id', 'sd_custom_' + entry.id)
-            .text(entry.title);
-        list.append(li);
-    }
-}
-function isValidState() {
-    switch (extension_settings.sd.source) {
-        case sources.extras:
-            return modules.includes('sd');
-        case sources.horde:
-            return true;
-        case sources.auto:
-            return !!extension_settings.sd.auto_url;
-        case sources.sdcpp:
-            return !!extension_settings.sd.sdcpp_url;
-        case sources.drawthings:
-            return !!extension_settings.sd.drawthings_url;
-        case sources.vlad:
-            return !!extension_settings.sd.vlad_url;
-        case sources.novel:
-            return secret_state[SECRET_KEYS.NOVEL];
-        case sources.openai:

public/scripts/extensions/stable-diffusion/manifest.json+0 -0 Viewed

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

public/scripts/extensions/stable-diffusion/style.css+0 -0 Viewed

public/scripts/openai.js+0 -0 Viewed

src/endpoints/backends/chat-completions.js+0 -0 Viewed

src/endpoints/keepalive.js+0 -0 Viewed

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

src/server-startup.js+0 -0 Viewed

tests/keepalive-scheduler.test.js+0 -0 Viewed

Diff truncated