sdmux 0.1.0__py3-none-any.whl

sdmux/__init__.py

@@ -0,0 +1,65 @@
+"""
+sdmux: one client for every local image generation backend, with checkpoint identification built in.
+
+    import sdmux
+
+    sd = sdmux.connect("http://127.0.0.1:8188")     # detects ComfyUI, A1111, Forge, SD.Next, SwarmUI or InvokeAI
+    r = sd.txt2img("1girl, smile <lora:detail:0.6>", model="waiIllustrious", steps=28, cfg=6,
+                   sampler="Euler a", scheduler="Karras", seed=42, clip_skip=2)
+    r.image.save("out.png")
+
+    info = sdmux.identify("model.safetensors")       # reads only the header
+    info.architecture, info.family, info.profile
+"""
+
+__version__ = "0.1.0"
+
+from .errors import AuthRefused, Cancelled, NotReady, Rejected, SdmuxError, TimedOut, Unreachable, Unsupported  # noqa: E402
+from .transport import Options  # noqa: E402
+from .types import Model, Progress, Request, Result  # noqa: E402
+from .comfygraph import Graph, GraphError, NodeSpec  # noqa: E402
+
+
+def connect(url: str, kind: str | None = None, options: Options | None = None, defaults: str = "profile",
+            **option_overrides):
+    """
+    Connect to the backend at url and return its client.
+
+    kind skips detection ("a1111", "forge", "reforge", "sdnext", "comfyui", "swarmui", "invokeai").
+    Connection options: username, password, token, headers, connect_timeout, timeout, job_timeout,
+    retries, verify_tls, poll_interval. Credentials in the URL (https://user:pass@host) work too.
+
+    defaults: "profile" (default) fills settings a call leaves out from the model's profile; "fixed" uses
+    sdmux's fixed size/steps/cfg and leaves sampler, scheduler and clip skip to the server.
+    """
+    from .backends import BACKENDS
+    from .probe import detect
+
+    if kind is None:
+        kind = detect(url, options, **option_overrides).kind
+    try:
+        cls = BACKENDS[kind.lower()]
+    except KeyError:
+        raise ValueError(f"Unknown backend kind {kind!r}. Known: {', '.join(sorted(BACKENDS))}") from None
+    return cls(url, options, defaults=defaults, **option_overrides)
+
+
+def detect(url: str, **option_overrides):
+    """Which backend answers at url. Returns a Detection (kind, evidence, version, tried)."""
+    from .probe import detect as _detect
+
+    return _detect(url, **option_overrides)
+
+
+def identify(path, online: bool = False, **kwargs):
+    """Identify a model file from its header (and sidecars, metadata, name; Civitai when online=True)."""
+    from .modelinfo import identify as _identify
+
+    return _identify(path, online=online, **kwargs)
+
+
+__all__ = [
+    "connect", "detect", "identify", "Options", "Graph", "GraphError", "NodeSpec", "Request", "Result", "Progress", "Model",
+    "SdmuxError", "Unreachable", "TimedOut", "AuthRefused", "NotReady", "Rejected", "Cancelled", "Unsupported",
+    "__version__",
+]

sdmux/backends/__init__.py

@@ -0,0 +1,17 @@
+from .a1111 import A1111, Forge, SDNext
+from .base import Backend
+from .comfyui import ComfyUI
+from .invokeai import InvokeAI
+from .swarmui import SwarmUI
+
+BACKENDS: dict[str, type[Backend]] = {
+    "a1111": A1111,
+    "forge": Forge,
+    "reforge": Forge,
+    "sdnext": SDNext,
+    "comfyui": ComfyUI,
+    "swarmui": SwarmUI,
+    "invokeai": InvokeAI,
+}
+
+__all__ = ["Backend", "A1111", "Forge", "SDNext", "ComfyUI", "SwarmUI", "InvokeAI", "BACKENDS"]

sdmux/backends/a1111.py

@@ -0,0 +1,308 @@
+"""
+AUTOMATIC1111, Forge / reForge and SD.Next, through the /sdapi/v1 API (A1111 and Forge need --api).
+
+Native escape hatch: api(path, payload) posts any body to any /sdapi/v1 route, and
+generate() merges Request.extra into the payload, so every field the WebUI accepts
+(alwayson_scripts, hires-fix, refiner, ...) is reachable.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+
+from ..errors import Cancelled, Rejected, SdmuxError
+from ..names import canonical_scheduler, extract_loras, lora_tags, pick_native, sampler_id
+from ..types import IMG2IMG, INPAINT, TXT2IMG, Model, Progress, Request, Result, load_image, to_b64
+from .base import Backend
+
+
+class A1111(Backend):
+    kind = "a1111"
+    label = "AUTOMATIC1111"
+    default_url = "http://127.0.0.1:7860"
+
+    #: When False (sdmux's choice), a model chosen with model= stays loaded after the call, like picking it
+    #: in the UI. A1111's own default (True) switches back after every call, reloading weights twice.
+    restore_settings = False
+
+    def __init__(self, url=None, options=None, **kw) -> None:
+        super().__init__(url, options, **kw)
+        self._schedulers: list[str] | None = None
+
+    # Listings -------------------------------------------------------------
+    def models(self) -> list[Model]:
+        return [
+            Model(
+                name=m.get("model_name") or m.get("title"),
+                title=m.get("title"),
+                path=m.get("filename"),
+                hash=m.get("hash"),
+                sha256=m.get("sha256"),
+                raw=m,
+            )
+            for m in self.http.get_json("/sdapi/v1/sd-models")
+        ]
+
+    def loras(self) -> list[Model]:
+        response = self.http.request("GET", "/sdapi/v1/loras")
+        if response.status_code == 404:
+            return []
+        items = self.http.json(self.http.check(response, "GET /sdapi/v1/loras"))
+        loras = []
+        for lora in items:
+            metadata = lora.get("metadata") or {}
+            loras.append(
+                Model(
+                    name=lora.get("name") or lora.get("alias"),
+                    title=lora.get("alias"),
+                    path=lora.get("path"),
+                    sha256=metadata.get("sshs_model_hash") if isinstance(metadata, dict) else None,
+                    kind="lora",
+                    raw=lora,
+                )
+            )
+        return loras
+
+    def samplers(self) -> list[str]:
+        return [s["name"] for s in self.http.get_json("/sdapi/v1/samplers")]
+
+    def schedulers(self) -> list[str]:
+        """Scheduler labels. [] where there is no /schedulers route (A1111 before 1.10, SD.Next)."""
+        if self._schedulers is None:
+            response = self.http.request("GET", "/sdapi/v1/schedulers")
+            if response.status_code >= 400:
+                self._schedulers = []  # 404 before A1111 1.10
+            else:
+                items = self.http.json(self.http.check(response, "GET /sdapi/v1/schedulers"))
+                self._schedulers = [s.get("label") or s.get("name") for s in items]
+        return list(self._schedulers)
+
+    def info(self) -> dict:
+        info = {"backend": self.kind, "url": self.url}
+        response = self.http.request("GET", "/sdapi/v1/version", timeout=10)
+        if response.status_code == 200:
+            try:
+                info["version"] = response.json()
+            except ValueError:
+                pass
+        try:
+            options = self.http.get_json("/sdapi/v1/options", timeout=10)
+            info["model"] = options.get("sd_model_checkpoint")
+        except Rejected:
+            pass
+        return info
+
+    def current_model(self) -> str | None:
+        """The checkpoint loaded on the server, which a request without model= runs on."""
+        try:
+            return self.http.get_json("/sdapi/v1/options", timeout=30).get("sd_model_checkpoint") or None
+        except SdmuxError:
+            return None
+
+    # Native ---------------------------------------------------------------
+    def api(self, path: str, payload: dict | None = None, method: str = "POST", timeout: float | None = None):
+        """Call any /sdapi/v1 route (path may omit the prefix) and return its JSON."""
+        if not path.startswith("/"):
+            path = "/sdapi/v1/" + path
+        response = self.http.request(method, path, json=payload, timeout=timeout)
+        return self.http.json(self.http.check(response, f"{method} {path}"))
+
+    # Generation -----------------------------------------------------------
+    def _sampler_fields(self, request: Request) -> dict:
+        from ..names import canonical_sampler
+
+        fields = {}
+        folded = None
+        if request.sampler:
+            _, folded = canonical_sampler(request.sampler)
+            native = pick_native(request.sampler, self.samplers(), sampler_id)
+            fields["sampler_name"] = native or request.sampler
+        scheduler = request.scheduler or folded
+        if scheduler:
+            schedulers = self.schedulers()
+            if schedulers:
+                fields["scheduler"] = pick_native(scheduler, schedulers, canonical_scheduler) or scheduler
+            elif request.sampler:
+                # No scheduler field (old A1111): A1111 reads a scheduler glued to the sampler name.
+                if canonical_scheduler(scheduler) not in ("automatic", "normal") and "sampler_name" in fields:
+                    from ..names import a1111_scheduler_label
+
+                    fields["sampler_name"] = f"{fields['sampler_name']} {a1111_scheduler_label(scheduler)}"
+        return fields
+
+    def build_payload(self, request: Request) -> dict:
+        """The /sdapi/v1/txt2img or /img2img body for a request (LoRA tags stay in the prompt)."""
+        prompt, loras = extract_loras(request.prompt)
+        if loras:
+            available = self.loras()
+            _, matched = self.resolve_loras(request.prompt, available)
+            prompt = " ".join(p for p in (prompt, lora_tags([(self.lora_name(m), w) for m, w in matched])) if p)
+        overrides: dict = {}
+        if request.model:
+            overrides["sd_model_checkpoint"] = self.resolve_model(request.model).title or request.model
+        if request.clip_skip:
+            overrides["CLIP_stop_at_last_layers"] = int(request.clip_skip)
+        if request.vae:
+            overrides["sd_vae"] = request.vae
+        payload = {
+            "prompt": prompt,
+            "negative_prompt": request.negative,
+            "width": request.width,
+            "height": request.height,
+            "steps": request.steps,
+            "cfg_scale": request.cfg,
+            "seed": request.seed if request.seed is not None else -1,
+            "batch_size": request.batch_size,
+            "n_iter": 1,
+            "send_images": True,
+            "save_images": False,
+        }
+        sampler_fields = self._sampler_fields(request)
+        overrides.update(sampler_fields.pop("override_settings", {}))
+        payload.update(sampler_fields)
+        if overrides:
+            payload["override_settings"] = overrides
+            payload["override_settings_restore_afterwards"] = self.restore_settings
+        if request.mode in (IMG2IMG, INPAINT):
+            payload["init_images"] = [to_b64(request.image.convert("RGB"))]
+            payload["denoising_strength"] = request.denoise
+            payload["resize_mode"] = 0
+        if request.mode == INPAINT:
+            payload.update(
+                {
+                    "mask": to_b64(request.mask.convert("L")),
+                    "mask_blur": request.mask_blur,
+                    "inpainting_fill": 1,  # start from the original pixels under the mask
+                    "inpaint_full_res": request.inpaint_full_res,
+                    "inpaint_full_res_padding": request.inpaint_padding,
+                    "inpainting_mask_invert": 0,  # white = repaint
+                }
+            )
+        payload.update(request.extra or {})
+        return payload
+
+    def _generate(self, request: Request) -> Result:
+        payload = self.build_payload(request)
+        route = "/sdapi/v1/txt2img" if request.mode == TXT2IMG else "/sdapi/v1/img2img"
+        with self._lock:
+            response = self.http.request("POST", route, json=payload, timeout=self.options.job_timeout)
+        if response.status_code >= 400:
+            raise Rejected(f"{self.label} rejected the request ({response.status_code}): {_error_text(response)}",
+                           backend=self.kind, details=response.text)
+        body = self.http.json(response)
+        images_b64 = body.get("images") or []
+        try:
+            info = json.loads(body.get("info") or "{}")
+        except (TypeError, ValueError):
+            info = {}
+        if not images_b64:
+            if self._cancel.is_set() or info.get("interrupted"):
+                raise Cancelled("Interrupted.", backend=self.kind)
+            raise Rejected(f"{self.label} returned no image.", backend=self.kind, details=body)
+        infotexts = info.get("infotexts") or []
+        seeds = info.get("all_seeds") or ([info["seed"]] if "seed" in info else [])
+        images = []
+        # Extensions may append extra images (masks, grids) beyond the batch; keep only the batch.
+        for index, data in enumerate(images_b64[: max(request.batch_size, 1)]):
+            image = load_image(data)
+            if index < len(infotexts):
+                image.info["parameters"] = infotexts[index]
+            images.append(image)
+        if self._cancel.is_set():
+            # A1111 answers an interrupted job with the partially denoised image; it is kept in details.
+            raise Cancelled("Interrupted.", backend=self.kind, details={"partial_images": images, "info": info})
+        return Result(
+            images=images,
+            seed=seeds[0] if seeds else info.get("seed"),
+            seeds=list(seeds),
+            parameters=infotexts[0] if infotexts else "",
+            backend=self.kind,
+            raw={"info": info, "parameters": body.get("parameters")},
+        )
+
+    # Control --------------------------------------------------------------
+    def progress(self) -> Progress:
+        r = self.http.get_json("/sdapi/v1/progress", params={"skip_current_image": "true"}, timeout=10)
+        state = r.get("state") or {}
+        active = bool(state.get("job")) or bool(state.get("job_count"))
+        step, steps = state.get("sampling_step") or 0, state.get("sampling_steps") or 0
+        eta = r.get("eta_relative")
+        return Progress(
+            fraction=float(r.get("progress") or 0.0) if active else 0.0,
+            step=step if active else None,
+            steps=steps if active else None,
+            eta=round(eta, 1) if active and eta and eta > 0 else None,
+            active=active,
+        )
+
+    def interrupt(self) -> None:
+        self._cancel.set()
+        self.http.check(self.http.request("POST", "/sdapi/v1/interrupt", timeout=10), "interrupt")
+
+
+def _error_text(response) -> str:
+    try:
+        body = response.json()
+    except ValueError:
+        return response.text[:1000]
+    if isinstance(body, dict):
+        return str(body.get("errors") or body.get("detail") or body.get("error") or body)[:1000]
+    return str(body)[:1000]
+
+
+class Forge(A1111):
+    """Stable Diffusion WebUI Forge and reForge: the A1111 API with different built-in scripts."""
+
+    kind = "forge"
+    label = "Forge"
+
+
+class SDNext(A1111):
+    """
+    SD.Next: the same /sdapi/v1 routes; it serves the API without --api.
+
+    SD.Next runs diffusers schedulers: the sampler list holds them all, and the A1111 scheduler is
+    approximated by its "Sigma algorithm" setting (schedulers_sigma: default, karras, exponential,
+    betas, lambdas, flowmatch). Its /sdapi/v1/schedulers lists samplers, not schedulers.
+    """
+
+    kind = "sdnext"
+    label = "SD.Next"
+    SIGMAS = ("default", "karras", "betas", "exponential", "lambdas", "flowmatch")
+
+    def schedulers(self) -> list[str]:
+        return list(self.SIGMAS)
+
+    def _sampler_fields(self, request: Request) -> dict:
+        from ..names import canonical_sampler
+
+        fields: dict = {}
+        folded = None
+        if request.sampler:
+            _, folded = canonical_sampler(request.sampler)
+            fields["sampler_name"] = pick_native(request.sampler, self.samplers(), sampler_id) or request.sampler
+        scheduler = request.scheduler or folded
+        if scheduler:
+            cid = canonical_scheduler(scheduler)
+            sigma = cid if cid in self.SIGMAS else ("betas" if cid == "beta" else "default")
+            fields["override_settings"] = {"schedulers_sigma": sigma}
+        return fields
+
+    def build_payload(self, request: Request) -> dict:
+        payload = super().build_payload(request)
+        if request.clip_skip:
+            payload["clip_skip"] = int(request.clip_skip)
+        # SD.Next ignores sd_model_checkpoint in override_settings when no model is loaded yet
+        # ("Aborted: op=process model not loaded"), so the model is switched through /options instead.
+        overrides = payload.get("override_settings") or {}
+        wanted = overrides.pop("sd_model_checkpoint", None)
+        if wanted:
+            current = self.http.get_json("/sdapi/v1/options", timeout=30).get("sd_model_checkpoint") or ""
+            if wanted not in (current, current.split(" [")[0]):
+                self.http.check(self.http.request("POST", "/sdapi/v1/options", json={"sd_model_checkpoint": wanted},
+                                                  timeout=self.options.job_timeout), "model switch")
+        if not overrides:
+            payload.pop("override_settings", None)
+            payload.pop("override_settings_restore_afterwards", None)
+        return payload

sdmux/backends/base.py

@@ -0,0 +1,270 @@
+"""The interface every backend implements, and the parts they share."""
+
+from __future__ import annotations
+
+import os
+import threading
+from typing import TYPE_CHECKING
+
+from ..errors import NotReady, Rejected
+from ..errors import SdmuxError
+from ..names import canonical_scheduler, extract_loras, lora_stem, match_choice
+from ..transport import Options, Transport
+from ..types import IMG2IMG, INPAINT, TXT2IMG, Model, Progress, Request, Result, load_image
+
+if TYPE_CHECKING:
+    from ..modelinfo import ModelInfo, Profile
+
+
+class Backend:
+    """
+    A connection to one image generation server.
+
+    Listings: models(), loras(), samplers(), schedulers(), info().
+    Generation: txt2img(), img2img(), inpaint(), or generate(Request). They raise on failure.
+    Control: progress(), interrupt().
+    Identification: identify(model), profile(model).
+
+    Every backend also exposes its native request path (see each subclass) so nothing the
+    unified surface lacks blocks you.
+    """
+
+    kind = ""
+    label = ""
+    default_url = "http://127.0.0.1:7860"
+
+    #: Fixed values for settings neither the caller nor the model profile provides.
+    FALLBACK = {"width": 512, "height": 512, "steps": 20, "cfg": 7.0}
+
+    def __init__(self, url: str | None = None, options: Options | None = None, defaults: str = "profile",
+                 **option_overrides) -> None:
+        """
+        defaults: "profile" (settings a call leaves out come from the model's profile: size, steps, cfg,
+        sampler, scheduler, clip skip) or "fixed" (sdmux's FALLBACK size, steps and cfg; sampler, scheduler
+        and clip skip are left to the server). Whatever is still missing after the profile gets FALLBACK.
+        """
+        if defaults not in ("profile", "fixed"):
+            raise ValueError("defaults must be 'profile' or 'fixed'.")
+        self.defaults = defaults
+        self._profiles: dict = {}
+        self.options = Options.build(options, **option_overrides)
+        self.http = Transport(url or self.default_url, self.options, self.label)
+        self.options = self.http.options
+        self._lock = threading.Lock()
+        self._cancel = threading.Event()
+
+    # Basics ---------------------------------------------------------------
+    @property
+    def url(self) -> str:
+        return self.http.base_url
+
+    def __repr__(self) -> str:
+        return f"<sdmux.{type(self).__name__} {self.kind} {self.url}>"
+
+    def close(self) -> None:
+        self.http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()
+
+    # Listings -------------------------------------------------------------
+    def models(self) -> list[Model]:
+        raise NotImplementedError
+
+    def loras(self) -> list[Model]:
+        return []
+
+    def samplers(self) -> list[str]:
+        return []
+
+    def schedulers(self) -> list[str]:
+        return []
+
+    def info(self) -> dict:
+        return {"backend": self.kind, "url": self.url}
+
+    def ready(self) -> dict:
+        """
+        A slim readiness check: {"ready": bool, "problems": [str], "info": {...}}.
+
+        Raises Unreachable / AuthRefused when the server cannot be talked to at all.
+        """
+        problems = []
+        info = self.info()
+        if not self.models():
+            problems.append(f"{self.label} lists no models.")
+        return {"ready": not problems, "problems": problems, "info": info}
+
+    # Generation -----------------------------------------------------------
+    def txt2img(self, prompt: str, negative: str = "", **kwargs) -> Result:
+        return self.generate(Request(prompt=prompt, negative=negative, mode=TXT2IMG, **kwargs))
+
+    def img2img(self, image, prompt: str, negative: str = "", denoise: float = 0.75, **kwargs) -> Result:
+        return self.generate(Request(prompt=prompt, negative=negative, mode=IMG2IMG, image=image, denoise=denoise, **kwargs))
+
+    def inpaint(self, image, mask, prompt: str, negative: str = "", denoise: float = 0.75, **kwargs) -> Result:
+        """White mask pixels are repainted, black ones kept."""
+        return self.generate(
+            Request(prompt=prompt, negative=negative, mode=INPAINT, image=image, mask=mask, denoise=denoise, **kwargs)
+        )
+
+    def generate(self, request: Request) -> Result:
+        request = self._prepare(request)
+        filled = self._fill_defaults(request)
+        self._cancel.clear()
+        result = self._generate(request)
+        result.defaults = filled
+        return result
+
+    def current_model(self) -> str | None:
+        """The model a request without model= runs on. Most backends use the first listed one."""
+        return None
+
+    def _profile_for(self, model):
+        key = model.name if isinstance(model, Model) else (model or self.current_model() or "")
+        if key not in self._profiles:
+            try:
+                resolved = self.resolve_model(model or self.current_model())
+                self._profiles[key] = (resolved.name, self.identify(resolved).profile)
+            except (SdmuxError, OSError, ValueError):
+                self._profiles[key] = (None, None)
+        return self._profiles[key]
+
+    def _fill_defaults(self, request: Request) -> dict:
+        """Fill settings the caller left as None; returns {field: (value, source)}."""
+        filled: dict = {}
+
+        def put(name, value, source):
+            if getattr(request, name) is None and value is not None:
+                setattr(request, name, value)
+                filled[name] = (value, source)
+
+        if self.defaults == "profile":
+            name, profile = self._profile_for(request.model)
+            if profile is not None:
+                source = f"profile:{name}"
+                if request.mode == TXT2IMG:
+                    put("width", profile.width, source)
+                    put("height", profile.height, source)
+                put("steps", profile.steps, source)
+                put("cfg", profile.cfg, source)
+                if request.sampler is None and request.scheduler is None:
+                    put("sampler", profile.sampler, source)
+                    scheduler = profile.scheduler if profile.scheduler and profile.scheduler.lower() != "automatic" else None
+                    put("scheduler", scheduler, source)
+                put("clip_skip", profile.clip_skip, source)
+        # Size, steps and cfg are always sent, so whatever is still missing gets sdmux's fixed values.
+        for name, value in self.FALLBACK.items():
+            put(name, value, "fallback")
+        return filled
+
+    def _generate(self, request: Request) -> Result:
+        raise NotImplementedError
+
+    def _prepare(self, request: Request) -> Request:
+        """Validate the request and load its images once, so backends receive PIL images."""
+        if request.mode not in (TXT2IMG, IMG2IMG, INPAINT):
+            raise ValueError(f"Unknown mode {request.mode!r}")
+        if request.mode in (IMG2IMG, INPAINT):
+            if request.image is None:
+                raise ValueError(f"{request.mode} needs an image.")
+            request.image = load_image(request.image)
+            if request.width is None:
+                request.width = request.image.width
+            if request.height is None:
+                request.height = request.image.height
+        if request.mode == INPAINT:
+            if request.mask is None:
+                raise ValueError("inpaint needs a mask (white = repaint).")
+            request.mask = load_image(request.mask)
+        if request.scheduler and canonical_scheduler(request.scheduler) == "automatic":
+            request.scheduler = None  # the backend's own default
+        if request.patch is not None and self.kind != "comfyui":
+            from ..errors import Unsupported
+
+            raise Unsupported(f"patch= edits a ComfyUI graph; {self.label} has none.", backend=self.kind)
+        if request.batch_size < 1:
+            raise ValueError("batch_size must be at least 1.")
+        return request
+
+    # Control --------------------------------------------------------------
+    def progress(self) -> Progress:
+        return Progress()
+
+    def interrupt(self) -> None:
+        raise NotImplementedError
+
+    # Shared helpers -------------------------------------------------------
+    def resolve_model(self, wanted: "str | Model | None", models: list[Model] | None = None) -> Model:
+        """The listed model matching wanted (loosely), or the first one when wanted is None. A Model passes through."""
+        if isinstance(wanted, Model):
+            return wanted
+        models = self.models() if models is None else models
+        if not models:
+            raise NotReady(f"{self.label} lists no models.", backend=self.kind)
+        if not wanted:
+            return models[0]
+        for attr in ("name", "title", "path"):
+            names = [getattr(m, attr) for m in models if getattr(m, attr)]
+            found = match_choice(wanted, names)
+            if found:
+                return next(m for m in models if getattr(m, attr) == found)
+        raise Rejected(
+            f"{self.label} has no model matching {wanted!r}. It lists: "
+            + ", ".join(m.name for m in models[:20]) + (" ..." if len(models) > 20 else ""),
+            backend=self.kind,
+        )
+
+    def resolve_loras(self, prompt: str, available: list[Model] | None = None) -> tuple[str, list[tuple[Model, float]]]:
+        """Strip <lora:...> tags from prompt and match each against the backend's LoRAs. Unknown LoRAs raise Rejected."""
+        cleaned, wanted = extract_loras(prompt)
+        if not wanted:
+            return cleaned, []
+        available = self.loras() if available is None else available
+        found = []
+        for name, weight in wanted:
+            match = None
+            for attr in ("name", "title", "path"):
+                names = [getattr(m, attr) for m in available if getattr(m, attr)]
+                hit = match_choice(name, names)
+                if hit:
+                    match = next(m for m in available if getattr(m, attr) == hit)
+                    break
+            if match is None:
+                raise Rejected(f"{self.label} has no LoRA matching {name!r}.", backend=self.kind)
+            found.append((match, weight))
+        return cleaned, found
+
+    @staticmethod
+    def lora_name(model: Model) -> str:
+        return lora_stem(model.name)
+
+    # Identification -------------------------------------------------------
+    def local_path(self, model: Model) -> str | None:
+        """The model's file on this machine, when the backend reports a path that exists here."""
+        if model.path and os.path.isfile(model.path):
+            return model.path
+        return None
+
+    def identify(self, model: str | Model, online: bool = False) -> "ModelInfo":
+        """
+        identify() for a listed model. Reads the file when it is reachable from this machine,
+        otherwise works from the name and whatever the backend reports about it.
+        """
+        from ..modelinfo import identify, identify_name
+
+        if not isinstance(model, Model):
+            model = self.resolve_model(model)
+        path = self.local_path(model)
+        if path:
+            return identify(path, online=online)
+        return identify_name(model.name, architecture=model.architecture, kind=model.kind, sha256=model.sha256, online=online)
+
+    def profile(self, model: str | Model | None = None) -> "Profile":
+        """Prompt dialect and starting defaults for a model this backend lists."""
+        if model is None or not isinstance(model, Model):
+            model = self.resolve_model(model)
+        return self.identify(model).profile