@bendyline/gezel-inference 1.0.5 → 1.0.7

package/dist/http/routes/v1-images.js

@@ -6,6 +6,8 @@ import { imageCatalogFits, imageModelFit, wontRunRefusal } from '../../models/im
 import { ReadOnlyModelError, modelExistsOnlyReadOnly, modelStorageRoots, } from '../../models/storage-roots.js';
 import { NoLocalImageModelError } from '../../providers/image/local-factory.js';
 import { ImageCapacityError, ImageGenerationCancelledError, } from '../../providers/image/types.js';
+import { registerImageEnsureRoutes } from './image-ensure-routes.js';
+import { v1ImageStylesRoutes } from './v1-image-styles.js';
 const log = createLogger('v1-images');
 /** The one local image engine this host serves. */
 const ENGINE = 'sd-cpp';
@@ -36,6 +38,7 @@ function describeManifest(manifest) {
         description: manifest.description,
         download_bytes: downloadBytes(manifest),
         ...(license ? { license } : {}),
+        ...(manifest.licenseUrl ? { license_url: manifest.licenseUrl } : {}),
         commercial_use: manifest.commercialUse,
         ...(manifest.rendersText !== undefined ? { renders_text: manifest.rendersText } : {}),
         ...(manifest.promptStyle ? { prompt_style: manifest.promptStyle } : {}),
@@ -49,36 +52,6 @@ function describeManifest(manifest) {
             : {}),
     };
 }
-function ensureEvent(jobId, event, totalBytes) {
-    const job = { jobId, modelId: qualified(jobId) };
-    switch (event.type) {
-        case 'progress':
-            return {
-                ...job,
-                type: 'progress',
-                bytesWritten: event.bytesWritten,
-                totalBytes: event.totalBytes ?? totalBytes,
-            };
-        case 'retrying':
-            return {
-                ...job,
-                type: 'retrying',
-                attempt: event.attempt,
-                maxAttempts: event.maxAttempts,
-                delayMs: event.delayMs,
-                reason: event.reason,
-            };
-        case 'error':
-            return { ...job, type: 'error', error: event.error };
-        case 'done':
-            return { ...job, type: 'done' };
-    }
-}
-function pullStatus(pull) {
-    if (!pull.finished)
-        return 'running';
-    return pull.error ? 'error' : 'done';
-}
 function generationError(err) {
     const message = err instanceof Error ? err.message : String(err);
     if (err instanceof ImageGenerationCancelledError)
@@ -117,6 +90,8 @@ function generationError(err) {
  */
 export function v1ImagesRoutes(ctx) {
     const app = new Hono();
+    if (ctx.images.loraPulls)
+        app.route('/styles', v1ImageStylesRoutes(ctx, ctx.images.loraPulls));
     const fitContext = { catalog: ctx.catalog, readConfig: () => ctx.store.readConfig() };
     app.get('/models', async (c) => {
         const provider = await ctx.images.current();
@@ -200,69 +175,7 @@ export function v1ImagesRoutes(ctx) {
         }
         return c.json({ status: 'downloading', model_id: qualified(id), job_id: id }, 202);
     });
-    app.get('/models/ensure/:jobId', (c) => {
-        const pull = ctx.images.pulls.get(c.req.param('jobId'));
-        if (!pull)
-            return c.json(apiError('job_not_found', 'job not found'), 404);
-        return c.json({
-            job_id: pull.id,
-            model_id: qualified(pull.id),
-            status: pullStatus(pull),
-            started_at: Date.parse(pull.startedAt),
-            bytes_written: pull.bytesWritten,
-            total_bytes: pull.totalBytes,
-            ...(pull.error ? { error: pull.error } : {}),
-        });
-    });
-    app.get('/models/ensure/:jobId/events', (c) => {
-        const jobId = c.req.param('jobId');
-        const snapshot = ctx.images.pulls.get(jobId);
-        if (!snapshot)
-            return c.json(apiError('job_not_found', 'job not found'), 404);
-        return streamSSE(c, async (stream) => {
-            let closed = false;
-            let sawError = false;
-            const unsubscribe = ctx.images.pulls.subscribe(jobId, (event) => {
-                // A failed pull ends with an error and then its done; the error is terminal.
-                if (sawError)
-                    return;
-                if (event.type === 'error')
-                    sawError = true;
-                const terminal = event.type === 'done' || event.type === 'error';
-                void stream
-                    .writeSSE({ data: JSON.stringify(ensureEvent(jobId, event, snapshot.totalBytes)) })
-                    .then(() => {
-                    if (terminal)
-                        closed = true;
-                })
-                    .catch(() => {
-                    closed = true;
-                });
-            });
-            if (!unsubscribe)
-                return;
-            stream.onAbort(() => {
-                closed = true;
-                unsubscribe();
-            });
-            while (!closed) {
-                await stream.sleep(1000);
-                try {
-                    await stream.writeSSE({ event: 'ping', data: '' });
-                }
-                catch {
-                    closed = true;
-                }
-            }
-            unsubscribe();
-        });
-    });
-    app.delete('/models/ensure/:jobId', (c) => {
-        if (!ctx.images.pulls.cancel(c.req.param('jobId'))) {
-            return c.json(apiError('job_not_found', 'No download in progress for that job'), 404);
-        }
-        return c.json({ cancelled: true });
-    });
+    registerImageEnsureRoutes(app, '/models/ensure', ctx.images.pulls, qualified);
     app.delete('/models/:id', async (c) => {
         const id = catalogIdOf(decodeURIComponent(c.req.param('id')));
         if (!id)
@@ -302,6 +215,14 @@ export function v1ImagesRoutes(ctx) {
                 : apiError('no_local_image_model', new NoLocalImageModelError().message);
             return c.json(error, 409);
         }
+        const style = request.style
+            ? installed
+                .find((model) => model.id === modelId)
+                ?.loras?.find((lora) => lora.id === request.style && lora.purpose === 'style')
+            : undefined;
+        if (request.style && !style) {
+            return c.json(apiError('style_not_available', 'That style is not installed for this image model.'), 409);
+        }
         const item = await ctx.catalog.get('image-model', modelId).catch(() => null);
         const manifest = item?.manifest.kind === 'image-model' ? item.manifest : undefined;
         const { width, height } = resolveImageSize({
@@ -338,6 +259,7 @@ export function v1ImagesRoutes(ctx) {
                     prompt: request.prompt,
                     ...(request.negative_prompt ? { negativePrompt: request.negative_prompt } : {}),
                     model: modelId,
+                    ...(style ? { loras: [{ id: style.id }] } : {}),
                     width,
                     height,
                     ...(request.seed !== undefined ? { seed: request.seed } : {}),

package/dist/inference-service.js

@@ -2,7 +2,7 @@ import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { join } from 'node:path';
 import { GEZEL_API_GENERATION, GEZEL_API_GENERATION_FLOOR, GEZEL_VERSION, GezelConfigSchema, createLogger, getLogOutput, nowIso, setLogOutput, startSuspendMonitor, stopSuspendMonitor, } from '@bendyline/gezel';
 import { BundledSource, CatalogService } from '@bendyline/gezel-catalog';
-import { discoverNativeBinaries } from '@bendyline/gezel/native';
+import { disableOnnxRuntimeTelemetry, discoverNativeBinaries } from '@bendyline/gezel/native';
 import { gezelHome } from '@bendyline/gezel/paths';
 import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
@@ -37,6 +37,7 @@ import './http/auth-context.js';
 const log = createLogger('inference');
 /** Direct Fetch host: no listener, product store, background downloads or daemon discovery. */
 export async function startService(options = {}) {
+    disableOnnxRuntimeTelemetry();
     const previousLogOutput = getLogOutput();
     const restoreLogOutput = () => setLogOutput(previousLogOutput);
     if (options.logOutput)

package/dist/knowledge/worker-host.js

@@ -7,6 +7,7 @@
  */
 import { Worker } from 'node:worker_threads';
 import { createLogger } from '@bendyline/gezel';
+import { disableOnnxRuntimeTelemetry } from '@bendyline/gezel/native';
 import { findServiceWorkerEntry } from '../utils/service-worker-entry.js';
 import { createInProcessCatalogHost } from './catalog-host.js';
 const log = createLogger('knowledge');
@@ -63,6 +64,7 @@ export function createWorkerCatalogHost() {
             return null;
         }
         try {
+            disableOnnxRuntimeTelemetry();
             const w = new Worker(entry);
             w.on('message', (msg) => {
                 const p = pending.get(msg.id);

package/dist/machine-engine/inspect-runtime.js

@@ -1,12 +1,21 @@
+import { innermostErrorReason } from '@bendyline/gezel';
 import { IdentityResponseSchema, certFingerprintFromPem, fingerprintOfPublicKeyPem, verifyIdentitySignature, } from '../remotes/identity.js';
 import { createPinnedFetch } from '../remotes/pinned-fetch.js';
 const MACHINE_REMOTE_ID = 'this-machine';
 export async function inspectMachineRuntime(runtime) {
     const fetchImpl = runtime.cert ? createPinnedFetch(runtime.cert) : fetch;
     try {
-        const response = await fetchImpl(`${runtime.baseUrl}/v1/identity`, {
-            signal: AbortSignal.timeout(5_000),
-        });
+        let response;
+        try {
+            response = await fetchImpl(`${runtime.baseUrl}/v1/identity`, {
+                signal: AbortSignal.timeout(5_000),
+            });
+        }
+        catch (error) {
+            // Bare, this surfaced as `fetch failed` in chat bubbles that never
+            // mentioned a machine engine at all.
+            throw new Error(`Gezel's machine engine at ${runtime.baseUrl} isn't answering (${innermostErrorReason(error)})`, { cause: error });
+        }
         if (!response.ok)
             throw new Error(`identity returned HTTP ${response.status}`);
         const identity = IdentityResponseSchema.parse(await response.json());

package/dist/memory/embed-core.js

@@ -15,6 +15,7 @@
 import { createHash } from 'node:crypto';
 import { createLogger, embeddingProfileArtifacts, } from '@bendyline/gezel';
 import { EmbedderUnavailableError, KNOWLEDGE_EMBEDDING_PROFILES, createProfileEmbedder, resolveTransformersModelOptions, verifyProfileArtifacts, } from '@bendyline/gezel-knowledge';
+import { disableOnnxRuntimeTelemetry } from '@bendyline/gezel/native';
 import { HF_CACHE_DIR_ENV, ModelFileDownloadError, TRANSFORMERS_MODULE, ensureVerifiedModelFile, isCorruptTransformersCacheFailure, isMissingModule, loadTransformersModelWithCacheRecovery, pinTransformersCacheDir, } from '../transformers-cache.js';
 export const log = createLogger('memory');
 /**
@@ -236,6 +237,7 @@ export async function loadPipeline() {
                 // and throws "Unable to get model file path or buffer". The dir is
                 // passed via env so this works in the embed worker thread too, which
                 // inherits `process.env` but has no other view of the gezel home.
+                disableOnnxRuntimeTelemetry();
                 const cacheDir = process.env[HF_CACHE_DIR_ENV];
                 if (cacheDir)
                     await pinTransformersCacheDir(cacheDir);
@@ -348,6 +350,7 @@ async function verifyDaemonPipeline() {
     }
 }
 async function defaultTransformersCacheDir() {
+    disableOnnxRuntimeTelemetry();
     const { env } = await import('@huggingface/transformers');
     // 4.x types it nullable: null only where there is no filesystem cache.
     return env.cacheDir ?? '';

package/dist/memory/embeddings.js

@@ -19,6 +19,7 @@
  */
 import { Worker } from 'node:worker_threads';
 import { createLogger, sameVectorSpace } from '@bendyline/gezel';
+import { disableOnnxRuntimeTelemetry } from '@bendyline/gezel/native';
 import { retireModelWorker } from '../utils/retire-model-worker.js';
 import { findServiceWorkerEntry } from '../utils/service-worker-entry.js';
 import { ModelWorkCancelledError, PipelineLoadError, cancelInFlightModelWork, daemonEmbedderPin, daemonEmbedderVerified, passageInstruction, queryInstruction, runEmbed, runProfileQueryEmbed, } from './embed-core.js';
@@ -124,6 +125,7 @@ function ensureWorker() {
         return null;
     }
     try {
+        disableOnnxRuntimeTelemetry();
         const w = new Worker(entry);
         w.on('message', onMessage);
         w.on('error', (err) => onWorkerDown(err instanceof Error ? err.message : String(err)));

package/dist/models/image-fit.js

@@ -11,12 +11,12 @@
  * The video half lives with the video engine in the service, which shares
  * the helpers here.
  */
-import { totalmem } from 'node:os';
 import { MEDIA_MODEL_WONT_RUN_CODE, assessMediaFit, createLogger, imageMemoryRequirement, imageModelDefaultSide, resolveImageSize, } from '@bendyline/gezel';
 import { isCudaArchivePath } from '@bendyline/gezel/native';
 import { sdServerLoadProfile } from '../providers/image/sd-cpp.js';
 import { configuredEngineMemoryBytes, staticCapacityCeilings, } from '../providers/native/device-capacity.js';
 import { measuredCapacityBudget } from '../providers/native/measured-budget.js';
+import { totalMemoryBytes } from '../system/host-memory.js';
 import { detectMemoryProfileCached } from '../system/memory.js';
 import { imageCatalogWeightFiles, sdCppMainComponent } from './weight-facts.js';
 const log = createLogger('media-fit');
@@ -63,7 +63,7 @@ export function imageMediaPool(kind, host = {
 /** The ceilings the device ledger applies on this machine, automatic and under the person's limit. */
 export async function mediaCapacity(pool, readConfig) {
     const budget = await measuredCapacityBudget();
-    const ram = totalmem();
+    const ram = totalMemoryBytes();
     const auto = staticCapacityCeilings(budget, ram);
     const configured = configuredEngineMemoryBytes(await readConfig().catch(() => ({})));
     const limited = configured === undefined ? undefined : staticCapacityCeilings(budget, ram, configured);

package/dist/models/weight-facts.d.ts

@@ -34,3 +34,8 @@ export declare function localSdCppWeightFiles(model: {
         path: string;
     }>;
 }): Promise<MediaWeightFile[]>;
+/** Weight files on disk, priced from their headers where they are safetensors. */
+export declare function localWeightFiles(entries: ReadonlyArray<{
+    component: string;
+    path: string;
+}>): Promise<MediaWeightFile[]>;

package/dist/models/weight-facts.js

@@ -148,10 +148,13 @@ export function imageCatalogWeightFiles(manifest) {
 }
 /** The weight files of an installed sd-cpp model, headers read from disk. */
 export async function localSdCppWeightFiles(model) {
-    const entries = [
+    return localWeightFiles([
         { component: sdCppMainComponent(model.weightsKind), path: model.weightsPath },
         ...model.auxiliaryFiles.map((a) => ({ component: a.role, path: a.path })),
-    ];
+    ]);
+}
+/** Weight files on disk, priced from their headers where they are safetensors. */
+export async function localWeightFiles(entries) {
     const out = [];
     for (const entry of entries) {
         const format = weightFileFormat(entry.path);

package/dist/providers/ds4/build-provider.js

@@ -123,7 +123,7 @@ export async function buildDs4Provider(opts) {
     // This tier assumes DeepSeek-V4's small resident footprint. A model whose
     // non-routed weights are much larger caps it further via the catalog's
     // `ds4.maxLaunchCtx`; see `resolveDs4LaunchCtx` below.
-    const totalRamBytes = (await import('node:os')).totalmem();
+    const totalRamBytes = (await import('../../system/host-memory.js')).totalMemoryBytes();
     const totalRamGb = totalRamBytes / 1024 ** 3;
     const ramTieredCtx = ds4RamTieredContext(totalRamBytes);
     const ds4ConstrainedToolNoSignalMs = (() => {

package/dist/providers/ds4/residency.js

@@ -1,5 +1,5 @@
-import { totalmem } from 'node:os';
 import { DS4_FULL_RESIDENCY_HEADROOM_BYTES, LLAMA_CPP_VISION_COMPUTE_BYTES, LLAMA_CPP_WEIGHTS_MULTIPLIER, ds4FitsFullResidency, } from '@bendyline/gezel';
+import { totalMemoryBytes } from '../../system/host-memory.js';
 const GB = 1024 ** 3;
 export { DS4_FULL_RESIDENCY_HEADROOM_BYTES };
 /**
@@ -43,7 +43,7 @@ export function ds4BaseResidentBytes(opts) {
 export function canUseDs4FullResidency(opts = {}) {
     return ds4FitsFullResidency({
         modelSizeBytes: opts.modelSizeBytes,
-        totalRamBytes: opts.totalRamBytes ?? totalmem(),
+        totalRamBytes: opts.totalRamBytes ?? totalMemoryBytes(),
         companionBytes: opts.companionBytes,
         platform: opts.platform ?? process.platform,
         arch: opts.arch ?? process.arch,
@@ -82,7 +82,7 @@ export function shouldUseDs4SsdStreaming(opts = {}) {
  * state + the cache cannot consume the runtime/OS reserve.
  */
 export function planDs4ExpertCache(opts) {
-    const totalRamBytes = opts.totalRamBytes ?? totalmem();
+    const totalRamBytes = opts.totalRamBytes ?? totalMemoryBytes();
     const catalogCacheBytes = opts.catalogCacheBytes ?? 0;
     const fixedResidentBytes = Math.max(0, (opts.catalogResidentBytes ?? 0) - catalogCacheBytes);
     const fallbackGb = totalRamBytes >= 120 * GB ? 64 : totalRamBytes >= 88 * GB ? 48 : 32;

package/dist/providers/image/img2img-support.d.ts

@@ -1,5 +1,7 @@
 /**
- * Per-model img2img capability resolution for the local sd-cpp engine.
+ * Per-model image-editing capability for the local sd-cpp engine: whether a
+ * model re-noises a source (img2img), reads sources as references beside an
+ * instruction, or cannot use one. The img2img half first.
  *
  * stable-diffusion.cpp's `/sdapi/v1/img2img` endpoint accepts
  * `init_images` for any loaded model, but whether the *architecture*
@@ -37,4 +39,37 @@ export interface Img2ImgSupportVerdict {
     /** Human-readable reason, set only when unsupported. */
     reason?: string;
 }
+/**
+ * Models that edit by reading source pictures as references beside an
+ * instruction (sd-server's `extra_images`), rather than re-noising one. The
+ * same ladder as above: a catalog `referenceImages` declaration persisted at
+ * pull time wins, then this map, which is how installs that predate the
+ * field learn it.
+ *
+ * FLUX.2 Klein: verified on the pinned engine (native sd-cpp master-975) on
+ * an RTX Spark, 2026-10-27, recoloring, adding an object and composing two
+ * sources at 4 steps in 12 s.
+ */
+export declare const MODEL_REFERENCE_EDIT_SUPPORT: Map<string, {
+    maxImages: number;
+    editOnly?: boolean;
+}>;
+export interface ImageEditCapabilityInput extends Img2ImgSupportInput {
+    /** Explicit `referenceImages` from catalog/installed metadata. */
+    referenceImages?: {
+        max: number;
+    } | undefined;
+    /** Explicit `editOnly` from catalog/installed metadata. */
+    editOnly?: boolean | undefined;
+}
+export interface ImageEditCapability {
+    /** Absent when the model cannot use a source picture at all. */
+    editMode?: 'reference' | 'img2img';
+    /** Sources one edit takes: the reference limit, or 1 for img2img. */
+    maxSourceImages?: number;
+    editOnly: boolean;
+    /** Why the model cannot edit; set only when `editMode` is absent. */
+    reason?: string;
+}
+export declare function resolveImageEditCapability(input: ImageEditCapabilityInput): ImageEditCapability;
 export declare function resolveImg2ImgSupport(input: Img2ImgSupportInput): Img2ImgSupportVerdict;

package/dist/providers/image/img2img-support.js

@@ -1,5 +1,7 @@
 /**
- * Per-model img2img capability resolution for the local sd-cpp engine.
+ * Per-model image-editing capability for the local sd-cpp engine: whether a
+ * model re-noises a source (img2img), reads sources as references beside an
+ * instruction, or cannot use one. The img2img half first.
  *
  * stable-diffusion.cpp's `/sdapi/v1/img2img` endpoint accepts
  * `init_images` for any loaded model, but whether the *architecture*
@@ -44,6 +46,33 @@ export const MODEL_IMG2IMG_SUPPORT = new Map([
     ['krea-2-turbo-q6', false],
     ['krea-2-turbo-q8', false],
 ]);
+/**
+ * Models that edit by reading source pictures as references beside an
+ * instruction (sd-server's `extra_images`), rather than re-noising one. The
+ * same ladder as above: a catalog `referenceImages` declaration persisted at
+ * pull time wins, then this map, which is how installs that predate the
+ * field learn it.
+ *
+ * FLUX.2 Klein: verified on the pinned engine (native sd-cpp master-975) on
+ * an RTX Spark, 2026-10-27, recoloring, adding an object and composing two
+ * sources at 4 steps in 12 s.
+ */
+export const MODEL_REFERENCE_EDIT_SUPPORT = new Map([
+    ['flux-2-klein-4b-q4', { maxImages: 3 }],
+    ['qwen-image-edit-2511-q4', { maxImages: 3, editOnly: true }],
+]);
+export function resolveImageEditCapability(input) {
+    const assessed = input.modelId ? MODEL_REFERENCE_EDIT_SUPPORT.get(input.modelId) : undefined;
+    const editOnly = input.editOnly ?? assessed?.editOnly ?? false;
+    const maxImages = input.referenceImages?.max ?? assessed?.maxImages;
+    if (maxImages !== undefined) {
+        return { editMode: 'reference', maxSourceImages: maxImages, editOnly };
+    }
+    const img2img = resolveImg2ImgSupport(input);
+    if (img2img.supported)
+        return { editMode: 'img2img', maxSourceImages: 1, editOnly };
+    return { editOnly, ...(img2img.reason ? { reason: img2img.reason } : {}) };
+}
 export function resolveImg2ImgSupport(input) {
     if (input.explicit !== undefined) {
         return input.explicit

package/dist/providers/image/local-engine.d.ts

@@ -21,6 +21,7 @@ export interface LocalImageEngineOptions {
 export declare class LocalImageEngine {
     private readonly opts;
     readonly pulls: ImageModelPullRegistry;
+    readonly loraPulls: ImageModelPullRegistry;
     private readonly lifecycle;
     constructor(opts: LocalImageEngineOptions);
     /** Whether this host can render at all: an engine binary, a server URL, or the mock. */

package/dist/providers/image/local-engine.js

@@ -1,6 +1,6 @@
 import { ProviderLifecycle } from '../provider-lifecycle.js';
 import { createLocalImageProvider } from './local-factory.js';
-import { ImageModelPullRegistry } from './pull-registry.js';
+import { ImageModelPullRegistry, imageLoraPullResolver } from './pull-registry.js';
 /**
  * Hosted inference's image engine: the local sd-server provider, built on
  * first use, plus the pulls that install its models. Reset drains in-flight
@@ -9,12 +9,17 @@ import { ImageModelPullRegistry } from './pull-registry.js';
 export class LocalImageEngine {
     opts;
     pulls;
+    loraPulls;
     // Only promise-returning operations can be tracked; a pull is an async
     // iterable and is cancelled through its own registry instead.
-    lifecycle = new ProviderLifecycle(new Set(['generate', 'deleteModel']));
+    lifecycle = new ProviderLifecycle(new Set(['generate', 'deleteModel', 'deleteLora']));
     constructor(opts) {
         this.opts = opts;
         this.pulls = new ImageModelPullRegistry({ imageProvider: this, catalog: opts.catalog });
+        this.loraPulls = new ImageModelPullRegistry({
+            resolve: imageLoraPullResolver(this, opts.catalog),
+            kind: 'image-lora',
+        });
     }
     /** Whether this host can render at all: an engine binary, a server URL, or the mock. */
     available() {
@@ -42,6 +47,7 @@ export class LocalImageEngine {
     }
     async shutdown() {
         this.pulls.clear();
+        this.loraPulls.clear();
         await this.lifecycle.reset();
     }
 }

package/dist/providers/image/local-factory.d.ts

@@ -15,6 +15,7 @@
  *      base URL (127.0.0.1:9081) and no supervisor. `health()` reports
  *      `not-configured` so the UI can say the engine is not installed.
  */
+import type { MediaWeightFile } from '@bendyline/gezel';
 import type { GpuArbiter } from '../gpu-arbiter.js';
 import type { NativeCapacityOptions } from '../native/device-capacity.js';
 import type { ImageProvider, InstalledImageModelInfo } from './types.js';
@@ -92,4 +93,12 @@ export interface ResolvedInstalledModel extends InstalledImageModelInfo {
  * encoder runs once per image, so GPUs lose nothing. `--diffusion-fa` means
  * `--flash-attn off,diffusion=on`, so that branch already leaves it off.
  */
-export declare function buildSdServerArgs(model: ResolvedInstalledModel, port: number): string[];
+export declare function buildSdServerArgs(model: ResolvedInstalledModel, port: number, opts?: {
+    loraDir?: string;
+}): string[];
+/**
+ * The LoRA files a render of `modelId` can hold at once (its fast mode and
+ * its largest style), priced like weights. Read when the engine launches, so
+ * a LoRA installed later counts from the next launch.
+ */
+export declare function launchedLoraWeightFiles(loraRoot: string, modelId: string): Promise<MediaWeightFile[]>;

package/dist/providers/image/local-factory.js

@@ -15,18 +15,18 @@
  *      base URL (127.0.0.1:9081) and no supervisor. `health()` reports
  *      `not-configured` so the UI can say the engine is not installed.
  */
-import { readFile } from 'node:fs/promises';
+import { mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { imageMediaPool, sdServerLedgerClaim, sdServerRequirement, } from '../../models/image-fit.js';
 import { findModelRoot, listOverlayModelIds, modelStorageRoots, verifyReadOnlyModelPayload, } from '../../models/storage-roots.js';
-import { localSdCppWeightFiles } from '../../models/weight-facts.js';
+import { localSdCppWeightFiles, localWeightFiles } from '../../models/weight-facts.js';
 import { pressureIdleGraceMs } from '../native/capacity-broker.js';
 import { measuredCapacityBudget } from '../native/measured-budget.js';
 import { pickFreePort } from '../native/port.js';
 import { NativeEngineSupervisor } from '../native/supervisor.js';
 import { patientFetch } from '../patient-fetch.js';
 import { MockImageProvider } from './mock.js';
-import { MODEL_SAMPLE_STEP_DEFAULTS, StableDiffusionCppProvider, sdServerLoadProfile, } from './sd-cpp.js';
+import { MODEL_SAMPLE_STEP_DEFAULTS, StableDiffusionCppProvider, readInstalledLoras, sdServerLoadProfile, } from './sd-cpp.js';
 /**
  * Nothing to generate with: the person has to download a model first. Its
  * own type so a route can answer with the fix, not a bare 500, which reads
@@ -80,6 +80,8 @@ export async function createLocalImageProvider(opts) {
         // when it changes; resolveLaunch reads it on the next start.
         const launchState = { modelId: undefined };
         let launchedModel;
+        const loraRoots = modelStorageRoots({ home: opts.home, engine: 'sd-cpp-loras', env });
+        const loraDir = loraRoots.writableRoot;
         const supervisor = new NativeEngineSupervisor({
             capacity: {
                 ...sdServerCapacity(opts.home),
@@ -93,7 +95,10 @@ export async function createLocalImageProvider(opts) {
                     const requirement = sdServerRequirement({
                         modelId: launchedModel.id,
                         weightsKind: launchedModel.weightsKind,
-                        files: await localSdCppWeightFiles(launchedModel),
+                        files: [
+                            ...(await localSdCppWeightFiles(launchedModel)),
+                            ...(await launchedLoraWeightFiles(loraDir, launchedModel.id)),
+                        ],
                         pool: imageMediaPool(budget.kind),
                     });
                     return sdServerLedgerClaim(requirement, budget.fastBytes);
@@ -131,9 +136,11 @@ export async function createLocalImageProvider(opts) {
                 if (!model)
                     throw new NoLocalImageModelError();
                 launchedModel = model;
+                // sd-server ignores a LoRA folder that does not exist yet, then lists none.
+                await mkdir(loraDir, { recursive: true });
                 return {
                     command: binary,
-                    args: buildSdServerArgs(model, port),
+                    args: buildSdServerArgs(model, port, { loraDir }),
                     baseUrl: `http://127.0.0.1:${port}`,
                 };
             },
@@ -146,6 +153,7 @@ export async function createLocalImageProvider(opts) {
             storageRoots,
             supervisor,
             launchState,
+            loraRoots,
             fetchImpl: patientFetch(),
             ...(defaultLocalModelId ? { defaultModelId: defaultLocalModelId } : {}),
             ...(opts.arbiter ? { arbiter: opts.arbiter } : {}),
@@ -239,7 +247,7 @@ async function findFirstInstalledModel(storageRoots) {
  * encoder runs once per image, so GPUs lose nothing. `--diffusion-fa` means
  * `--flash-attn off,diffusion=on`, so that branch already leaves it off.
  */
-export function buildSdServerArgs(model, port) {
+export function buildSdServerArgs(model, port, opts = {}) {
     const args = [];
     if (model.weightsKind === 'diffusion-model') {
         args.push('--diffusion-model', model.weightsPath);
@@ -265,6 +273,25 @@ export function buildSdServerArgs(model, port) {
         args.push('--vae-tiling');
     if (profile.stepCache)
         args.push('--cache-mode', profile.stepCache);
+    if (profile.modelArgs)
+        args.push('--model-args', profile.modelArgs);
+    // At runtime for every model: a LoRA then changes per request without
+    // touching the weights. In auto mode an unquantized checkpoint (SD, SDXL)
+    // would merge it into the weights instead.
+    if (opts.loraDir)
+        args.push('--lora-model-dir', opts.loraDir, '--lora-apply-mode', 'at_runtime');
     args.push('--listen-ip', '127.0.0.1', '--listen-port', String(port));
     return args;
 }
+/**
+ * The LoRA files a render of `modelId` can hold at once (its fast mode and
+ * its largest style), priced like weights. Read when the engine launches, so
+ * a LoRA installed later counts from the next launch.
+ */
+export async function launchedLoraWeightFiles(loraRoot, modelId) {
+    const fitting = (await readInstalledLoras(loraRoot)).filter((l) => l.baseModels.includes(modelId));
+    const largest = (purpose) => fitting
+        .filter((l) => l.purpose === purpose)
+        .sort((a, b) => b.approxSizeBytes - a.approxSizeBytes)[0];
+    return localWeightFiles([largest('speed'), largest('style')].flatMap((l) => l ? [{ component: 'lora', path: join(loraRoot, l.id, l.filename) }] : []));
+}

package/dist/providers/image/mock.d.ts

@@ -4,19 +4,26 @@
  * colour is derived from a hash of the prompt so different prompts yield
  * visually different (but still trivially small) outputs.
  */
-import type { ImageEngineHealth, ImageGenerationInput, ImageGenerationOutput, ImageModelPullEvent, ImageModelPullSpec, ImageProvider, InstalledImageModelInfo } from './types.js';
+import type { ImageEngineHealth, ImageGenerationInput, ImageGenerationOutput, ImageLoraPullSpec, ImageModelPullEvent, ImageModelPullSpec, ImageProvider, InstalledImageLoraInfo, InstalledImageModelInfo } from './types.js';
 export declare class MockImageProvider implements ImageProvider {
     readonly name = "mock";
     private readonly installed;
+    private readonly loras;
     /** Internal counter driving deterministic seed generation on "random" seeds. */
     private nextSeed;
     constructor(opts?: {
         preinstalled?: InstalledImageModelInfo[];
+        loras?: InstalledImageLoraInfo[];
     });
     /** Number of input images received on the most recent generate(). Tests use this. */
     lastInputImageCount: number;
+    /** The most recent generate() input. Tests use this. */
+    lastInput: ImageGenerationInput | undefined;
     generate(input: ImageGenerationInput): Promise<ImageGenerationOutput>;
     listInstalledModels(): Promise<InstalledImageModelInfo[]>;
+    listLoras(): Promise<InstalledImageLoraInfo[]>;
+    pullLora(id: string, spec: ImageLoraPullSpec): AsyncIterable<ImageModelPullEvent>;
+    deleteLora(id: string): Promise<void>;
     pullModel(id: string, spec: ImageModelPullSpec, signal?: AbortSignal): AsyncIterable<ImageModelPullEvent>;
     deleteModel(id: string): Promise<void>;
     health(): Promise<ImageEngineHealth>;