@bendyline/gezel-inference 1.0.5 → 1.0.7

package/dist/providers/image/mock.js

@@ -8,22 +8,33 @@ import { deflateSync } from 'node:zlib';
 export class MockImageProvider {
     name = 'mock';
     installed = new Map();
+    loras = new Map();
     /** Internal counter driving deterministic seed generation on "random" seeds. */
     nextSeed = 1;
     constructor(opts = {}) {
         for (const m of opts.preinstalled ?? []) {
             this.installed.set(m.id, m);
         }
+        for (const l of opts.loras ?? [])
+            this.loras.set(l.id, l);
     }
     /** Number of input images received on the most recent generate(). Tests use this. */
     lastInputImageCount = 0;
+    /** The most recent generate() input. Tests use this. */
+    lastInput;
     async generate(input) {
         this.lastInputImageCount = input.inputImages?.length ?? 0;
+        this.lastInput = input;
         const width = clamp(input.width ?? 16, 1, 512);
         const height = clamp(input.height ?? 16, 1, 512);
         const steps = clamp(input.steps ?? 1, 1, 100);
         const seed = input.seed ?? this.nextSeed++;
         const model = input.model ?? [...this.installed.keys()][0] ?? 'mock-model';
+        // Applied as the real engine applies them: installed, and fitting the model.
+        const loras = (input.loras ?? []).flatMap(({ id }) => {
+            const lora = this.loras.get(id);
+            return lora?.baseModels.includes(model) ? [{ id: lora.id, name: lora.name }] : [];
+        });
         const rgba = solidFill(width, height, colourForPrompt(input.prompt));
         const png = encodePng(rgba, width, height);
         return {
@@ -35,11 +46,45 @@ export class MockImageProvider {
                 widthPx: width,
                 heightPx: height,
                 durationMs: 1,
+                ...(loras.length > 0 ? { loras } : {}),
             },
         };
     }
     async listInstalledModels() {
-        return [...this.installed.values()];
+        return [...this.installed.values()].map((m) => {
+            const loras = [...this.loras.values()]
+                .filter((l) => l.baseModels.includes(m.id))
+                .map(({ id, name, purpose, steps }) => ({
+                id,
+                name,
+                purpose,
+                ...(steps !== undefined ? { steps } : {}),
+            }));
+            return loras.length > 0 ? { ...m, loras } : m;
+        });
+    }
+    async listLoras() {
+        return [...this.loras.values()];
+    }
+    async *pullLora(id, spec) {
+        yield {
+            type: 'progress',
+            bytesWritten: spec.approxSizeBytes,
+            totalBytes: spec.approxSizeBytes,
+        };
+        this.loras.set(id, {
+            id,
+            name: spec.name,
+            purpose: spec.purpose,
+            ...(spec.render?.steps !== undefined ? { steps: spec.render.steps } : {}),
+            baseModels: spec.baseModels,
+            approxSizeBytes: spec.approxSizeBytes,
+            installedAt: new Date().toISOString(),
+        });
+        yield { type: 'done', id };
+    }
+    async deleteLora(id) {
+        this.loras.delete(id);
     }
     async *pullModel(id, spec, signal) {
         const total = spec.approxSizeBytes;

package/dist/providers/image/pull-registry.d.ts

@@ -34,6 +34,13 @@ type Listener = (event: ImageModelPullEvent) => void;
 export interface ImageProviderSource {
     current(): Promise<Pick<ImageProvider, 'pullModel'>>;
 }
+/** One download the registry runs: its expected size and the event stream. */
+export interface ImagePullJob {
+    totalBytes: number;
+    run(signal: AbortSignal): AsyncIterable<ImageModelPullEvent>;
+}
+/** Turns a catalog id into a pull, or `null` for an id the catalog lacks. */
+export type ImagePullResolver = (id: string) => Promise<ImagePullJob | null>;
 /**
  * Owns the lifecycle of every in-flight image-model pull.
  *
@@ -52,11 +59,18 @@ export interface ImageProviderSource {
 export declare class ImageModelPullRegistry {
     private readonly entries;
     private readonly controllers;
-    private readonly imageProvider;
-    private readonly catalog;
+    private readonly resolve;
+    private readonly kind;
+    /**
+     * Image models by default; `resolve` makes it a registry for another kind
+     * of download (LoRAs), whose ids then never share keys with models.
+     */
     constructor(opts: {
         imageProvider: ImageProviderSource;
         catalog: CatalogService;
+    } | {
+        resolve: ImagePullResolver;
+        kind: string;
     });
     /**
      * Start a pull for `id`. Idempotent — when a pull is already in flight
@@ -101,6 +115,14 @@ export declare class ImageModelPullRegistry {
 }
 export declare class UnknownImageModelError extends Error {
     readonly id: string;
-    constructor(id: string);
+    constructor(id: string, kind?: string);
 }
+/**
+ * LoRA pulls: the catalog's `image-lora` entries, installed by whichever
+ * provider owns the engine. A provider without LoRA support fails the pull
+ * with a plain message.
+ */
+export declare function imageLoraPullResolver(imageProvider: {
+    current(): Promise<Pick<ImageProvider, 'pullLora'>>;
+}, catalog: CatalogService): ImagePullResolver;
 export {};

package/dist/providers/image/pull-registry.js

@@ -25,11 +25,21 @@ const FINISHED_TTL_MS = 8_000;
 export class ImageModelPullRegistry {
     entries = new Map();
     controllers = new Map();
-    imageProvider;
-    catalog;
+    resolve;
+    kind;
+    /**
+     * Image models by default; `resolve` makes it a registry for another kind
+     * of download (LoRAs), whose ids then never share keys with models.
+     */
     constructor(opts) {
-        this.imageProvider = opts.imageProvider;
-        this.catalog = opts.catalog;
+        if ('resolve' in opts) {
+            this.resolve = opts.resolve;
+            this.kind = opts.kind;
+        }
+        else {
+            this.resolve = imageModelPullResolver(opts.imageProvider, opts.catalog);
+            this.kind = 'image-model';
+        }
     }
     /**
      * Start a pull for `id`. Idempotent — when a pull is already in flight
@@ -47,40 +57,21 @@ export class ImageModelPullRegistry {
         }
         // Resolve the catalog entry up-front so we can fail fast with a
         // proper 404 rather than emitting a 200 + error SSE for "unknown id".
-        const item = await this.catalog.get('image-model', id);
-        if (!item || item.manifest.kind !== 'image-model') {
-            throw new UnknownImageModelError(id);
-        }
-        const manifest = item.manifest;
+        const job = await this.resolve(id);
+        if (!job)
+            throw new UnknownImageModelError(id, this.kind);
         const snapshot = {
             id,
             startedAt: new Date().toISOString(),
             bytesWritten: 0,
-            totalBytes: manifest.approxSizeBytes +
-                manifest.auxiliaryFiles.reduce((n, f) => n + f.approxSizeBytes, 0),
+            totalBytes: job.totalBytes,
             finished: false,
         };
         const entry = { snapshot, listeners: new Set() };
         this.entries.set(id, entry);
         const controller = new AbortController();
         this.controllers.set(id, controller);
-        const spec = {
-            downloadUrl: manifest.downloadUrl,
-            sha256: manifest.sha256,
-            approxSizeBytes: manifest.approxSizeBytes,
-            name: manifest.name,
-            weightsKind: manifest.weightsKind,
-            ...(manifest.supportsImg2Img !== undefined
-                ? { supportsImg2Img: manifest.supportsImg2Img }
-                : {}),
-            auxiliaryFiles: manifest.auxiliaryFiles.map((aux) => ({
-                role: aux.role,
-                downloadUrl: aux.downloadUrl,
-                sha256: aux.sha256,
-                approxSizeBytes: aux.approxSizeBytes,
-            })),
-        };
-        void this.consume(id, spec, controller.signal);
+        void this.consume(id, job, controller.signal);
         return { snapshot: { ...snapshot }, alreadyRunning: false };
     }
     list() {
@@ -148,13 +139,12 @@ export class ImageModelPullRegistry {
         if (snapshot.finished && !snapshot.error)
             listener({ type: 'done', id: snapshot.id });
     }
-    async consume(id, spec, signal) {
+    async consume(id, job, signal) {
         const entry = this.entries.get(id);
         if (!entry)
             return;
         try {
-            const provider = await this.imageProvider.current();
-            for await (const event of provider.pullModel(id, spec, signal)) {
+            for await (const event of job.run(signal)) {
                 this.applyEvent(entry, event);
                 this.broadcast(entry, event);
                 if (event.type === 'done' || event.type === 'error')
@@ -171,7 +161,8 @@ export class ImageModelPullRegistry {
         finally {
             entry.snapshot.finished = true;
             // Drop the controller — cancel() should be a no-op once finished.
-            this.controllers.delete(id);
+            if (this.entries.get(id) === entry)
+                this.controllers.delete(id);
             // Keep the snapshot around briefly so a client mid-reconnect still
             // sees the terminal state on `list()` / `subscribe()`. Then garbage
             // collect.
@@ -184,6 +175,9 @@ export class ImageModelPullRegistry {
     }
     applyEvent(entry, event) {
         const s = entry.snapshot;
+        // Publish terminal state before generator cleanup can yield to a new subscriber.
+        if (event.type === 'done' || event.type === 'error')
+            s.finished = true;
         if (event.type === 'progress') {
             s.bytesWritten = event.bytesWritten;
             if (event.totalBytes !== undefined)
@@ -219,9 +213,77 @@ export class ImageModelPullRegistry {
 }
 export class UnknownImageModelError extends Error {
     id;
-    constructor(id) {
-        super(`unknown image-model: ${id}`);
+    constructor(id, kind = 'image-model') {
+        super(`unknown ${kind}: ${id}`);
         this.id = id;
         this.name = 'UnknownImageModelError';
     }
 }
+function imageModelPullResolver(imageProvider, catalog) {
+    return async (id) => {
+        const item = await catalog.get('image-model', id);
+        if (!item || item.manifest.kind !== 'image-model')
+            return null;
+        const manifest = item.manifest;
+        const spec = {
+            downloadUrl: manifest.downloadUrl,
+            sha256: manifest.sha256,
+            approxSizeBytes: manifest.approxSizeBytes,
+            name: manifest.name,
+            weightsKind: manifest.weightsKind,
+            ...(manifest.supportsImg2Img !== undefined
+                ? { supportsImg2Img: manifest.supportsImg2Img }
+                : {}),
+            ...(manifest.referenceImages ? { referenceImages: manifest.referenceImages } : {}),
+            ...(manifest.editOnly !== undefined ? { editOnly: manifest.editOnly } : {}),
+            auxiliaryFiles: manifest.auxiliaryFiles.map((aux) => ({
+                role: aux.role,
+                downloadUrl: aux.downloadUrl,
+                sha256: aux.sha256,
+                approxSizeBytes: aux.approxSizeBytes,
+            })),
+        };
+        return {
+            totalBytes: manifest.approxSizeBytes +
+                manifest.auxiliaryFiles.reduce((n, f) => n + f.approxSizeBytes, 0),
+            async *run(signal) {
+                const provider = await imageProvider.current();
+                yield* provider.pullModel(id, spec, signal);
+            },
+        };
+    };
+}
+/**
+ * LoRA pulls: the catalog's `image-lora` entries, installed by whichever
+ * provider owns the engine. A provider without LoRA support fails the pull
+ * with a plain message.
+ */
+export function imageLoraPullResolver(imageProvider, catalog) {
+    return async (id) => {
+        const item = await catalog.get('image-lora', id);
+        if (!item || item.manifest.kind !== 'image-lora')
+            return null;
+        const manifest = item.manifest;
+        const spec = {
+            downloadUrl: manifest.downloadUrl,
+            sha256: manifest.sha256,
+            approxSizeBytes: manifest.approxSizeBytes,
+            name: manifest.name,
+            baseModels: manifest.baseModels,
+            purpose: manifest.purpose,
+            strength: manifest.strength,
+            ...(manifest.prompt ? { prompt: manifest.prompt } : {}),
+            ...(manifest.render ? { render: manifest.render } : {}),
+        };
+        return {
+            totalBytes: manifest.approxSizeBytes,
+            async *run(signal) {
+                const provider = await imageProvider.current();
+                if (!provider.pullLora) {
+                    throw new Error('This image engine cannot add styles or fast mode.');
+                }
+                yield* provider.pullLora(id, spec, signal);
+            },
+        };
+    };
+}

package/dist/providers/image/sd-cpp.d.ts

@@ -15,10 +15,11 @@
  * catalog manifest (so local state is self-describing even if the
  * catalog entry later disappears).
  */
+import { type ImageLoraPrompt, type ImageLoraPurpose, type ImageLoraRender } from '@bendyline/gezel';
 import { type ModelStorageRoots } from '../../models/storage-roots.js';
 import type { GpuArbiter } from '../gpu-arbiter.js';
 import type { NativeEngineSupervisor } from '../native/supervisor.js';
-import { type ImageEngineHealth, type ImageGenerationInput, type ImageGenerationOutput, type ImageGenerationProgress, type ImageModelPullEvent, type ImageModelPullSpec, type ImageProvider, type InstalledImageModelInfo } from './types.js';
+import { type ImageEngineHealth, type ImageGenerationInput, type ImageGenerationOutput, type ImageGenerationProgress, type ImageLoraPullSpec, type ImageModelPullEvent, type ImageModelPullSpec, type ImageProvider, type InstalledImageLoraInfo, type InstalledImageModelInfo } from './types.js';
 export interface StableDiffusionCppProviderOptions {
     /** Base URL of the running sd-server (no trailing slash). */
     baseUrl: string;
@@ -26,6 +27,13 @@ export interface StableDiffusionCppProviderOptions {
     modelsRoot: string;
     /** Optional read-only machine-store overlay. */
     storageRoots?: ModelStorageRoots;
+    /**
+     * Where LoRAs install (`modelStorageRoots({ engine: 'sd-cpp-loras' })`).
+     * Only the writable root reaches the engine, which takes one
+     * `--lora-model-dir`. Absent when the engine is someone else's server
+     * (`GEZEL_SD_SERVER_URL`): renders then go without LoRAs, with a note.
+     */
+    loraRoots?: ModelStorageRoots;
     /** Awake-time budget for one render request, in ms. Defaults to 30 minutes. */
     timeoutMs?: number;
     /** Injected for tests. Defaults to global fetch. */
@@ -130,6 +138,8 @@ export interface SdServerLoadProfile {
      * measured not to change.
      */
     stepCache?: 'easycache';
+    /** `--model-args` key=value list. See MODEL_ARGS. */
+    modelArgs?: string;
 }
 export declare function sdServerLoadProfile(modelId: string): SdServerLoadProfile;
 export declare class StableDiffusionCppProvider implements ImageProvider {
@@ -137,6 +147,7 @@ export declare class StableDiffusionCppProvider implements ImageProvider {
     private readonly baseUrl;
     private readonly modelsRoot;
     private readonly storageRoots;
+    private readonly loraRoots?;
     private readonly timeoutMs;
     private readonly fetchImpl;
     private readonly supervisor?;
@@ -150,6 +161,28 @@ export declare class StableDiffusionCppProvider implements ImageProvider {
     generate(input: ImageGenerationInput): Promise<ImageGenerationOutput>;
     private generateInner;
     listInstalledModels(): Promise<InstalledImageModelInfo[]>;
+    /** Installed LoRAs, from the root the engine reads; none when this engine takes none. */
+    listLoras(): Promise<InstalledImageLoraInfo[]>;
+    /**
+     * Install one LoRA: a single safetensors file, sha256-checked like a model,
+     * beside a `manifest.json` that keeps the catalog's recipe so the engine can
+     * apply it without the catalog.
+     */
+    pullLora(id: string, spec: ImageLoraPullSpec, signal?: AbortSignal): AsyncIterable<ImageModelPullEvent>;
+    deleteLora(id: string): Promise<void>;
+    /**
+     * The LoRAs a render asked for that this engine can apply to `modelId`:
+     * installed in the root the engine reads and checked on that model. The
+     * rest are dropped with a note, never an error.
+     */
+    private resolveLoras;
+    /**
+     * Keep the LoRAs the running engine can see. sd-server fills its LoRA list
+     * only when it is asked for it, and answers `invalid lora path` for any LoRA
+     * named before then, so the list is read before every LoRA render.
+     */
+    private lorasTheEngineHas;
+    private readInstalledLora;
     pullModel(id: string, spec: ImageModelPullSpec, signal?: AbortSignal): AsyncIterable<ImageModelPullEvent>;
     /**
      * Stream a single URL to disk with sha256 verification, reporting cumulative
@@ -167,11 +200,13 @@ export declare class StableDiffusionCppProvider implements ImageProvider {
     health(): Promise<ImageEngineHealth>;
     shutdown(): Promise<void>;
     /**
-     * The configured default when it is installed, else the first installed
-     * model id, else undefined. Stable ordering matches
-     * {@link listInstalledModels} so the default is deterministic.
+     * The model a fresh picture renders with: the configured default when it
+     * is installed and draws, else the first installed model that draws. Stable
+     * ordering matches {@link listInstalledModels} so the default is
+     * deterministic.
      */
     resolveDefaultModelId(): Promise<string | undefined>;
+    private chooseModel;
     private defaultSampleSteps;
     /**
      * Read the installed `manifest.json` fields that steer per-model
@@ -182,6 +217,30 @@ export declare class StableDiffusionCppProvider implements ImageProvider {
      */
     private readInstalledManifestFields;
 }
+/**
+ * sd-server reads `<sd_cpp_extra_args>{json}</sd_cpp_extra_args>` out of a
+ * prompt and applies the JSON as generation parameters, including LoRA and
+ * ADetailer model paths it never checks. Prompts come from gezels reading
+ * untrusted content and from other apps, so the tag never reaches the engine.
+ * Repeated until stable: removing one tag can join the pieces around it into
+ * another.
+ */
+export declare function withoutEngineDirectives(text: string): string;
+/** An installed LoRA with the recipe its catalog entry gave it. */
+export interface InstalledLora {
+    id: string;
+    name: string;
+    filename: string;
+    purpose: ImageLoraPurpose;
+    strength: number;
+    baseModels: string[];
+    prompt?: ImageLoraPrompt;
+    render?: ImageLoraRender;
+    approxSizeBytes: number;
+    installedAt: string;
+}
+/** Every LoRA installed under `loraRoot`, skipping malformed ones. */
+export declare function readInstalledLoras(loraRoot: string): Promise<InstalledLora[]>;
 /**
  * Parse one line of sd-server's weight-load bar, which it prints inside the
  * first request after a launch because it loads weights lazily: