@bendyline/gezel-inference 1.0.3 → 1.0.5

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

@@ -0,0 +1,370 @@
+import { AppImageGenerationRequestSchema, createLogger, imageModelDefaultSide, resolveImageSize, } from '@bendyline/gezel';
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { z } from 'zod';
+import { imageCatalogFits, imageModelFit, wontRunRefusal } from '../../models/image-fit.js';
+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';
+const log = createLogger('v1-images');
+/** The one local image engine this host serves. */
+const ENGINE = 'sd-cpp';
+const EnsureRequestSchema = z.object({ model: z.string().min(1, 'model is required') });
+function apiError(code, message) {
+    return { error: { message, type: 'invalid_request_error', code } };
+}
+/** `sd-cpp:<id>` or a bare `<id>`; null for another engine's id. */
+function catalogIdOf(model) {
+    const trimmed = model.trim();
+    const colon = trimmed.indexOf(':');
+    if (colon < 0)
+        return trimmed || null;
+    if (trimmed.slice(0, colon) !== ENGINE)
+        return null;
+    return trimmed.slice(colon + 1).trim() || null;
+}
+function qualified(catalogId) {
+    return `${ENGINE}:${catalogId}`;
+}
+function downloadBytes(manifest) {
+    return (manifest.approxSizeBytes + manifest.auxiliaryFiles.reduce((n, f) => n + f.approxSizeBytes, 0));
+}
+function describeManifest(manifest) {
+    const license = manifest.licenseShortName ?? manifest.license;
+    return {
+        name: manifest.name,
+        description: manifest.description,
+        download_bytes: downloadBytes(manifest),
+        ...(license ? { license } : {}),
+        commercial_use: manifest.commercialUse,
+        ...(manifest.rendersText !== undefined ? { renders_text: manifest.rendersText } : {}),
+        ...(manifest.promptStyle ? { prompt_style: manifest.promptStyle } : {}),
+        ...(manifest.hardwareTier ? { hardware_tier: manifest.hardwareTier } : {}),
+        ...(manifest.minRamGB !== undefined ? { min_ram_gb: manifest.minRamGB } : {}),
+        ...(manifest.widthRange ? { width_range: manifest.widthRange } : {}),
+        ...(manifest.heightRange ? { height_range: manifest.heightRange } : {}),
+        default_side_px: imageModelDefaultSide(manifest.id),
+        ...(manifest.supportsImg2Img !== undefined
+            ? { supports_img2img: manifest.supportsImg2Img }
+            : {}),
+    };
+}
+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)
+        return { code: 'cancelled', message };
+    if (err instanceof ImageCapacityError)
+        return { code: err.code, message };
+    if (err instanceof NoLocalImageModelError)
+        return { code: err.code, message };
+    const code = err?.code;
+    if (code === 'capacity-denied')
+        return { code: 'capacity_denied', message };
+    return { code: 'image_generation_failed', message };
+}
+/**
+ * `/v1/images/*` — local image generation for apps.
+ *
+ *   GET    /models                   Installed and downloadable image models,
+ *                                    with this machine's fit. Never part of
+ *                                    `/v1/models`, so chat pickers never
+ *                                    offer them.
+ *   POST   /models/ensure            `{model: "sd-cpp:<id>"}` → ready, or a
+ *                                    background download (`job_id`).
+ *   GET    /models/ensure/:jobId     Snapshot of a download.
+ *   GET    /models/ensure/:jobId/events
+ *                                    SSE of `AppEnsureEvent`s, closing after
+ *                                    `done` or `error`. Disconnecting does
+ *                                    not cancel the download.
+ *   DELETE /models/ensure/:jobId     Cancel the download; a later ensure
+ *                                    resumes it.
+ *   DELETE /models/:id               Remove an installed model. A shared
+ *                                    model belongs to another store: 409.
+ *   POST   /generations              SSE of `AppImageGenerationEvent`s:
+ *                                    progress, then one `done` (the PNG) or
+ *                                    `error`. Closing the stream cancels the
+ *                                    render, which stops the engine.
+ */
+export function v1ImagesRoutes(ctx) {
+    const app = new Hono();
+    const fitContext = { catalog: ctx.catalog, readConfig: () => ctx.store.readConfig() };
+    app.get('/models', async (c) => {
+        const provider = await ctx.images.current();
+        const [installed, items, fits] = await Promise.all([
+            provider.listInstalledModels(),
+            ctx.catalog.list('image-model'),
+            imageCatalogFits(fitContext).catch((error) => {
+                log.warn(`[v1-images] fit assessment failed: ${String(error)}`);
+                return null;
+            }),
+        ]);
+        const storageRoots = modelStorageRoots({ home: ctx.home, engine: ENGINE });
+        const installedIds = new Set(installed.map((m) => m.id));
+        const fitById = new Map(fits?.models.map((m) => [m.id, m]) ?? []);
+        const downloading = new Set(ctx.images.pulls
+            .list()
+            .filter((p) => !p.finished)
+            .map((p) => p.id));
+        const data = [];
+        const seen = new Set();
+        for (const item of items) {
+            const manifest = item.manifest;
+            if (manifest.kind !== 'image-model')
+                continue;
+            seen.add(manifest.id);
+            const fit = fitById.get(manifest.id);
+            const isInstalled = installedIds.has(manifest.id);
+            data.push({
+                id: qualified(manifest.id),
+                object: 'image_model',
+                ...describeManifest(manifest),
+                name: manifest.name,
+                availability: isInstalled
+                    ? 'available'
+                    : downloading.has(manifest.id)
+                        ? 'downloading'
+                        : 'download-required',
+                ...(isInstalled && (await modelExistsOnlyReadOnly(storageRoots, manifest.id))
+                    ? { shared: true }
+                    : {}),
+                ...(fit ? { fit: { verdict: fit.verdict, reason: fit.reason } } : {}),
+            });
+        }
+        // Installed models the catalog no longer lists still render.
+        for (const model of installed) {
+            if (seen.has(model.id))
+                continue;
+            data.push({
+                id: qualified(model.id),
+                object: 'image_model',
+                name: model.name,
+                availability: 'available',
+                ...((await modelExistsOnlyReadOnly(storageRoots, model.id)) ? { shared: true } : {}),
+                ...(model.supportsImg2Img !== undefined ? { supports_img2img: model.supportsImg2Img } : {}),
+            });
+        }
+        return c.json({ object: 'list', data });
+    });
+    app.post('/models/ensure', async (c) => {
+        const { model } = EnsureRequestSchema.parse(await c.req.json());
+        const id = catalogIdOf(model);
+        if (!id) {
+            return c.json(apiError('unsupported_backend', `Image models are ${ENGINE}:<id>`), 400);
+        }
+        const provider = await ctx.images.current();
+        const installed = await provider.listInstalledModels();
+        if (installed.some((m) => m.id === id)) {
+            return c.json({ status: 'ready', model_id: qualified(id) });
+        }
+        const refusal = await wontRunRefusal(() => imageModelFit(fitContext, id));
+        if (refusal)
+            return c.json(apiError(refusal.code, refusal.error), 409);
+        try {
+            await ctx.images.pulls.start(id);
+        }
+        catch (error) {
+            if (error.name === 'UnknownImageModelError') {
+                return c.json(apiError('unknown_model', `No image model ${model} in the catalog`), 404);
+            }
+            throw error;
+        }
+        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 });
+    });
+    app.delete('/models/:id', async (c) => {
+        const id = catalogIdOf(decodeURIComponent(c.req.param('id')));
+        if (!id)
+            return c.json(apiError('unsupported_backend', `Image models are ${ENGINE}:<id>`), 400);
+        const storageRoots = modelStorageRoots({ home: ctx.home, engine: ENGINE });
+        if (await modelExistsOnlyReadOnly(storageRoots, id)) {
+            return c.json(apiError('shared_model', 'This model is shared from another store and is not removed here'), 409);
+        }
+        // The engine may hold the model's files open.
+        await ctx.images.reset();
+        try {
+            await (await ctx.images.current()).deleteModel(id);
+        }
+        catch (error) {
+            if (error instanceof ReadOnlyModelError) {
+                return c.json(apiError('shared_model', error.message), 409);
+            }
+            throw error;
+        }
+        return c.body(null, 204);
+    });
+    app.post('/generations', async (c) => {
+        const request = AppImageGenerationRequestSchema.parse(await c.req.json());
+        if (!ctx.images.available()) {
+            return c.json(apiError('images_unavailable', 'Image generation is not available on this computer'), 503);
+        }
+        const provider = await ctx.images.current();
+        const installed = await provider.listInstalledModels();
+        const requested = request.model ? catalogIdOf(request.model) : undefined;
+        if (request.model && !requested) {
+            return c.json(apiError('unsupported_backend', `Image models are ${ENGINE}:<id>`), 400);
+        }
+        const modelId = requested ?? (await provider.resolveDefaultModelId?.());
+        if (!modelId || !installed.some((m) => m.id === modelId)) {
+            const error = requested
+                ? apiError('model_not_installed', `${request.model} is not installed; ensure it first`)
+                : apiError('no_local_image_model', new NoLocalImageModelError().message);
+            return c.json(error, 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({
+            ...(request.aspect_ratio ? { aspectRatio: request.aspect_ratio } : {}),
+            ...(request.quality ? { quality: request.quality } : {}),
+        }, {
+            defaultSidePx: imageModelDefaultSide(modelId),
+            ...(manifest?.widthRange ? { widthRange: manifest.widthRange } : {}),
+            ...(manifest?.heightRange ? { heightRange: manifest.heightRange } : {}),
+        });
+        return streamSSE(c, async (stream) => {
+            const controller = new AbortController();
+            const cancel = () => controller.abort();
+            stream.onAbort(cancel);
+            c.req.raw.signal.addEventListener('abort', cancel, { once: true });
+            const send = (event) => stream.writeSSE({ data: JSON.stringify(event) }).catch(cancel);
+            let last = '';
+            const onProgress = (progress) => {
+                const event = {
+                    type: 'progress',
+                    phase: progress.phase ?? 'sampling',
+                    step: progress.step,
+                    total_steps: progress.totalSteps,
+                    ...(progress.secondsPerStep ? { seconds_per_step: progress.secondsPerStep } : {}),
+                };
+                const key = JSON.stringify(event);
+                if (key === last)
+                    return;
+                last = key;
+                void send(event);
+            };
+            try {
+                const out = await provider.generate({
+                    prompt: request.prompt,
+                    ...(request.negative_prompt ? { negativePrompt: request.negative_prompt } : {}),
+                    model: modelId,
+                    width,
+                    height,
+                    ...(request.seed !== undefined ? { seed: request.seed } : {}),
+                    signal: controller.signal,
+                    onProgress,
+                });
+                await send({
+                    type: 'done',
+                    b64_png: out.png.toString('base64'),
+                    width: out.meta.widthPx,
+                    height: out.meta.heightPx,
+                    seed: out.meta.seed,
+                    model: qualified(out.meta.model),
+                    steps: out.meta.steps,
+                    duration_ms: out.meta.durationMs,
+                });
+            }
+            catch (error) {
+                if (!controller.signal.aborted) {
+                    log.warn(`[v1-images] generation failed: ${String(error)}`);
+                }
+                await send({ type: 'error', error: generationError(error) });
+            }
+            finally {
+                c.req.raw.signal.removeEventListener('abort', cancel);
+            }
+        });
+    });
+    return app;
+}

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

@@ -1,4 +1,4 @@
-import { createLogger } from '@bendyline/gezel';
+import { createLogger, toolCallBlockedHistoryEntry } from '@bendyline/gezel';
 import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
 import { streamSSE } from 'hono/streaming';
@@ -11,6 +11,7 @@ import { resolveChatTarget, resolvePinnedModelTarget, } from '../openai-compat/c
 import { engineFailure } from '../openai-compat/engine-failure.js';
 import { runResponsesNonStreaming, runResponsesStreaming, } from '../openai-compat/responses-streaming.js';
 import { ResponsesRequestSchema, translateResponsesRequest, } from '../openai-compat/responses-translate.js';
+import { createToolCallScreen } from '../openai-compat/tool-call-screen.js';
 import { flattenTranscriptIntoPrompt, parseGezelModelRef, resolveModelTarget, } from '../openai-compat/translate.js';
 const log = createLogger('v1-responses');
 const MAX_RESPONSES_BODY_BYTES = 16 * 1024 * 1024;
@@ -180,8 +181,19 @@ export function v1ResponsesRoutes(ctx, opts = {}) {
             const detachRequestAbort = () => {
                 requestSignal.removeEventListener('abort', abortTurn);
             };
+            const toolCallScreen = createToolCallScreen((tool, indicators) => {
+                const entry = toolCallBlockedHistoryEntry({
+                    tool,
+                    surface: 'responses',
+                    indicators,
+                    appId,
+                });
+                log.warn(`${entry.summary} (app ${appId})`);
+                void ctx.history?.log(entry).catch(() => { });
+            });
             const runnerOptions = {
                 ...(attachments.length > 0 ? { attachments } : {}),
+                toolCallScreen,
                 ...(lengthCapTokens !== undefined ? { lengthCapTokens } : {}),
                 toolBindings: translated.toolBindings,
                 toolKinds: translated.toolKinds,

package/dist/inference-service.d.ts

@@ -1,4 +1,5 @@
 import { type LogOutput, type ProviderName } from '@bendyline/gezel';
+import type { ImageProvider } from './providers/image/types.js';
 import type { LLMProvider } from './providers/types.js';
 import './http/auth-context.js';
 /** Same shape the full service reports, so one handler serves either host. */
@@ -14,6 +15,8 @@ export interface InferenceServiceOptions {
     home?: string;
     /** Host-provided local providers, useful for testing without downloading weights. */
     providers?: ReadonlyMap<ProviderName, LLMProvider>;
+    /** Host-provided image provider in place of the local engine, for tests. */
+    imageProvider?: ImageProvider;
     onUnexpectedHttpError?: (event: InferenceHttpErrorEvent) => void;
     /**
      * Where log records go while this host runs; restored on `stop()`. An app

package/dist/inference-service.js

@@ -14,6 +14,7 @@ import { enginesRoutes } from './http/routes/engines.js';
 import { modelBundleRoutes } from './http/routes/model-bundles.js';
 import { v1ChatRoutes } from './http/routes/v1-chat.js';
 import { v1EmbeddingsRoutes } from './http/routes/v1-embeddings.js';
+import { v1ImagesRoutes } from './http/routes/v1-images.js';
 import { v1KnowledgeRoutes } from './http/routes/v1-knowledge.js';
 import { v1ModelsEnsureRoutes } from './http/routes/v1-models-ensure.js';
 import { v1ModelsRoutes } from './http/routes/v1-models.js';
@@ -23,6 +24,7 @@ import { KnowledgeManager } from './knowledge/manager.js';
 import { createWorkerCatalogHost } from './knowledge/worker-host.js';
 import { embeddingsHealth, openEmbeddings, shutdownEmbeddings } from './memory/embeddings.js';
 import { AppleFoundationModelsProvider } from './providers/apple-foundation-models/provider.js';
+import { LocalImageEngine } from './providers/image/local-engine.js';
 import { EngineInference } from './providers/native/inference.js';
 import { resolveModelSessionDefaults } from './providers/session-defaults.js';
 import { MlxRuntimeStatusBus } from './python/mlx-runtime-status-bus.js';
@@ -157,7 +159,25 @@ export async function startService(options = {}) {
         await knowledge.start();
         const relevance = new RelevanceModelManager({ home, readConfig: () => store.readConfig() });
         cleanup.push(() => relevanceScorer().dispose());
-        const context = { home, store, catalog, chat, knowledge, relevance, ...components };
+        const images = new LocalImageEngine({
+            home,
+            catalog,
+            arbiter: components.gpuArbiter,
+            readConfig: () => store.readConfig(),
+            ...(options.imageProvider ? { provider: options.imageProvider } : {}),
+        });
+        cleanup.push(() => images.shutdown());
+        const context = {
+            home,
+            store,
+            catalog,
+            chat,
+            knowledge,
+            relevance,
+            images,
+            imageProvider: images,
+            ...components,
+        };
         const clientToken = randomBytes(32).toString('base64url');
         const tokenBytes = Buffer.from(clientToken);
         const app = new Hono();
@@ -191,12 +211,13 @@ export async function startService(options = {}) {
             nodeVersion: process.versions.node,
             platform: process.platform,
             embeddings: embeddingsHealth(),
+            images: { available: images.available() },
         }));
         app.use('*', async (c, next) => {
             const candidate = Buffer.from(c.req.header('authorization')?.replace(/^Bearer /, '') ?? '');
             if (candidate.length !== tokenBytes.length || !timingSafeEqual(candidate, tokenBytes))
                 return c.json({ error: 'Unauthorized' }, 401);
-            c.set('auth', { appId: 'host', scopes: ['openai', 'knowledge'] });
+            c.set('auth', { appId: 'host', scopes: ['openai', 'knowledge', 'images'] });
             return next();
         });
         const allowedProviders = ['llama-cpp', 'mlx', 'ds4', 'apple-foundation-models'];
@@ -207,6 +228,7 @@ export async function startService(options = {}) {
         app.route('/v1/models/ensure', v1ModelsEnsureRoutes(context));
         app.route('/v1/models', v1ModelsRoutes(context, { localOnly: true }));
         app.route('/v1/knowledge', v1KnowledgeRoutes(context));
+        app.route('/v1/images', v1ImagesRoutes(context));
         app.route('/api/engines', enginesRoutes(context));
         app.route('/api/model-bundles', modelBundleRoutes(context));
         for (const [engine, manager] of [

package/dist/kokoro-lexicon/manifest.json

@@ -1,8 +1,11 @@
 {
   "source": {
-    "url": "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/kokoro-int8-multi-lang-v1_0.tar.bz2",
-    "sha256": "4c3052abaa60943a341f193888cf6abd68787dae6ab8ae5c925a706caa247e4e",
-    "file": "kokoro-model.tar.bz2"
+    "url": "https://huggingface.co/csukuangfj/kokoro-int8-multi-lang-v1_0/resolve/57adb37fc0e8d4bd430cfc1b8f8c2294945b9af2/",
+    "files": {
+      "lexicon-us-en.txt": "7daaab53a181be9885b853a8582bf1838186317e5dadacbcef9c426d6fa0da14",
+      "lexicon-gb-en.txt": "c4cbb37316f62210dff52718a7afcaae24f50c032cc75ab47ae67b831d1049e7",
+      "LICENSE": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30"
+    }
   },
   "license": {
     "file": "LICENSE",

package/dist/models/image-fit.d.ts

@@ -0,0 +1,83 @@
+/**
+ * "Can this machine run that image model?" for the image catalog.
+ *
+ * Prices each catalog entry from the weight facts its gilde entry pins (core
+ * `media-memory.ts`) — never the network — and checks it against the same
+ * static ceilings the device ledger refuses at, so `wont-run` here means the
+ * launch path would refuse the model on this machine whatever else is
+ * running. The download pages hide those models and the pull routes refuse
+ * them. Contract: docs/media-model-memory.md.
+ *
+ * The video half lives with the video engine in the service, which shares
+ * the helpers here.
+ */
+import { type GezelConfig, type ImageModelManifest, type ImageQuality, type MediaCapacity, type MediaFitAssessment, type MediaMemoryPool, type MediaMemoryRequirement, type MediaModelFit, type MediaModelFitResponse, type MediaWeightFile } from '@bendyline/gezel';
+import type { CatalogService } from '@bendyline/gezel-catalog';
+import type { CapacityBudgetKind } from '../providers/native/capacity-budget.js';
+export interface MediaFitContext {
+    catalog: CatalogService;
+    readConfig: () => Promise<Pick<GezelConfig, 'localEngineMemoryGb'>>;
+}
+/**
+ * The 409 body a pull route answers with when the model cannot run here, or
+ * null to let the pull start. A failure to assess never blocks a download:
+ * the launch path still applies the same check.
+ */
+export declare function wontRunRefusal(assess: () => Promise<MediaFitAssessment | null>): Promise<{
+    error: string;
+    code: string;
+} | null>;
+/**
+ * Where sd-server keeps weights: Metal on Apple Silicon, CPU on Intel Macs,
+ * CUDA or Vulkan elsewhere, falling back to the processor when no GPU
+ * answers. Windows on Arm runs on the processor unless discovery picked its
+ * CUDA build, which only an RTX Spark gets.
+ */
+export declare function imageMediaPool(kind: CapacityBudgetKind, host?: {
+    platform: NodeJS.Platform;
+    arch: string;
+    sdServerBin?: string | undefined;
+}): MediaMemoryPool;
+/** The ceilings the device ledger applies on this machine, automatic and under the person's limit. */
+export declare function mediaCapacity(pool: MediaMemoryPool, readConfig: MediaFitContext['readConfig']): Promise<MediaCapacity>;
+/** The memory sd-server needs for one model, from its weight files and its launch profile. */
+export declare function sdServerRequirement(input: {
+    modelId: string;
+    weightsKind: 'checkpoint' | 'diffusion-model';
+    files: readonly MediaWeightFile[];
+    pool: MediaMemoryPool;
+    /** The render size to price; the model's default size when absent. */
+    megapixels?: number;
+}): MediaMemoryRequirement;
+/**
+ * What a launched sd-server claims on the device ledger.
+ *
+ * On a discrete card the fit figures charge graphics memory for weights only,
+ * because sd-server can stream components from RAM, and the download page
+ * must not call a model that offloads "won't run". A running render holds its
+ * compute buffers on the card too, though: FLUX.2 Klein at 1024px held
+ * 9.4 GiB of a 12 GiB card's dedicated memory against 4.9 GiB of weights
+ * (RTX 5070 Ti Laptop, Vulkan, M0 spike 2026-10-25). Claiming weights only
+ * let a resident chat model keep its memory, and the render then failed at
+ * its first step. The claim is the estimated peak, capped at the card so a
+ * model that must offload is admitted once the card is otherwise free.
+ */
+export declare function sdServerLedgerClaim(requirement: MediaMemoryRequirement, cardBytes: number): {
+    bytes: number;
+    gpuBytes: number;
+};
+/** Megapixels a model renders at a quality tier, inside its range. */
+export declare function imageRenderMegapixels(manifest: Pick<ImageModelManifest, 'id' | 'widthRange' | 'heightRange'>, quality: ImageQuality): number;
+export interface FitPlan {
+    pool: MediaMemoryPool;
+    capacity: MediaCapacity;
+}
+export declare function mediaFitResponse(plan: FitPlan, models: MediaModelFit[]): MediaModelFitResponse;
+/**
+ * Every catalog image model's fit. With `quality`, each is priced at the size
+ * it renders at that tier rather than its default, which is how the direct
+ * image gezel's settings know whether High will fit.
+ */
+export declare function imageCatalogFits(ctx: MediaFitContext, quality?: ImageQuality): Promise<MediaModelFitResponse>;
+/** One catalog image model's fit, or null when the id is not in the catalog. */
+export declare function imageModelFit(ctx: MediaFitContext, id: string): Promise<MediaFitAssessment | null>;