@bendyline/gezel-inference 1.0.2 → 1.0.4

package/dist/engines/native-manifest.d.ts

@@ -40,12 +40,12 @@
  * but logs that it could not anchor to a baked-in digest.
  */
 /** Native release version this build pins. Placeholder until first public release. */
-export declare const NATIVE_ENGINE_RELEASE = "0.1.51";
+export declare const NATIVE_ENGINE_RELEASE = "0.1.54";
 /** sha256 of the pinned release's `SHA256SUMS` asset. All-zeros = unpinned. */
-export declare const SHA256SUMS_DIGEST = "499a87aa18e113cdb52ee277bff71365e9176b63b536dbea7f3c2aa5ff5dbe68";
-/** Exact SHA256 values for every engine archive published by native-v0.1.51. */
+export declare const SHA256SUMS_DIGEST = "087215a12096127a779b20e0dcb7d2ed9ce5dda1c81f33fdeb6b6eb730485b20";
+/** Exact SHA256 values for every engine archive published by native-v0.1.54. */
 export declare const NATIVE_ENGINE_ARCHIVE_SHA256: Readonly<Record<string, string>>;
-/** Download size in bytes of every engine archive published by native-v0.1.51. */
+/** Download size in bytes of every engine archive published by native-v0.1.54. */
 export declare const NATIVE_ENGINE_ARCHIVE_BYTES: Readonly<Record<string, number>>;
 /**
  * True only when the pinned release's standalone macOS archives were

package/dist/engines/native-manifest.js

@@ -40,45 +40,47 @@
  * but logs that it could not anchor to a baked-in digest.
  */
 /** Native release version this build pins. Placeholder until first public release. */
-export const NATIVE_ENGINE_RELEASE = '0.1.51';
+export const NATIVE_ENGINE_RELEASE = '0.1.54';
 /** sha256 of the pinned release's `SHA256SUMS` asset. All-zeros = unpinned. */
-export const SHA256SUMS_DIGEST = '499a87aa18e113cdb52ee277bff71365e9176b63b536dbea7f3c2aa5ff5dbe68';
+export const SHA256SUMS_DIGEST = '087215a12096127a779b20e0dcb7d2ed9ce5dda1c81f33fdeb6b6eb730485b20';
 // BEGIN PINNED NATIVE ARCHIVE HASHES
-/** Exact SHA256 values for every engine archive published by native-v0.1.51. */
+/** Exact SHA256 values for every engine archive published by native-v0.1.54. */
 export const NATIVE_ENGINE_ARCHIVE_SHA256 = Object.freeze({
-    'gezel-native-0.1.51-darwin-arm64-metal.tar.gz': '5abbfd156fbcc717da96c89dc5baa507a56d2b55b501f1a975803a763e6414c4',
-    'gezel-native-0.1.51-darwin-arm64.tar.gz': '799bca88b0ea10aeb2dad9ed3065c9396f42383a6fd5c7347ed76abf0706f128',
-    'gezel-native-0.1.51-linux-arm64-cpu.tar.gz': '1612e5928693262884bcc2c60ba3975af4dc4267c2bd75597ef91e83681fa96e',
-    'gezel-native-0.1.51-linux-arm64-cuda.tar.gz': '4a457df5dbb8475ca0eb2f1a2373f1960bbb3f86a0ecd938a407f884cd6026a2',
-    'gezel-native-0.1.51-linux-arm64.tar.gz': '2aaead65bfd42ffef9a1f45a70fa24095bc2814842750536989cbcb7a9a0db24',
-    'gezel-native-0.1.51-linux-x64-cpu.tar.gz': '7453d6a3ef2de7ece967a033d5bd634789e41edefa4a823b580329f0ad98abb0',
-    'gezel-native-0.1.51-linux-x64-cuda.tar.gz': 'ac1054a33339bcf6167c309b867f5671def58e036bb612978c4a434cd7ac39d6',
-    'gezel-native-0.1.51-linux-x64-vulkan.tar.gz': '6739c9dca6cbcf53fb5d69dbd342ac6be49fe2f0d86471d66975e61a64c95e9f',
-    'gezel-native-0.1.51-linux-x64.tar.gz': 'a176ac570131db874e0a81fdec939415dd161a639827219a82f2a610f5ebd8d3',
-    'gezel-native-0.1.51-win32-arm64-cpu.zip': 'f79c0c8490d46f2d60e73fd948bf74ae93dfc7c650a878f7db5e227bbdbb85b9',
-    'gezel-native-0.1.51-win32-arm64.zip': 'c829c9c1fd08756aff9e677ea1addcf80a8739f13df3c9b6788a6237e53efacb',
-    'gezel-native-0.1.51-win32-x64-cpu.zip': 'f8e0ffeacc8aeea1f2fc91024382bdcdaeeeb65b8a45935af422acb4d7027190',
-    'gezel-native-0.1.51-win32-x64-cuda.zip': '6bd7dc2c43443a847058a4c4f1c53281c99563c214394a92470281a70f725d1e',
-    'gezel-native-0.1.51-win32-x64-vulkan.zip': 'e20fb148c854f267aa50981525e337c38d3ee496fd483393a676251d9c0a496f',
-    'gezel-native-0.1.51-win32-x64.zip': 'ca5d7866fa2ff2e89da9267fcb409eb9aff01ef1c43ed726327e4967d3ed5e56',
+    'gezel-native-0.1.54-darwin-arm64-metal.tar.gz': 'f2990970303b954af2fd2e2bd31efef7d1c231bea16e026e0cdc0a7f9cc17842',
+    'gezel-native-0.1.54-darwin-arm64.tar.gz': '850f28338c52f945996c55edd77cf14d451c9bc4a09f719f6608885ddab99687',
+    'gezel-native-0.1.54-linux-arm64-cpu.tar.gz': '7dac7fed45c46b591cd6d597d639c385f54a3a367ac15d6097d3ad04d9c3c6e6',
+    'gezel-native-0.1.54-linux-arm64-cuda.tar.gz': 'f73c4569c356c4584199513c6c1f1f0bd3f0151fb1845696e2fa43f2b3626803',
+    'gezel-native-0.1.54-linux-arm64.tar.gz': 'f034ad2d3d12165c979d2fff2d34752c8d4f8ff836d3c416c9c64535f3bb652b',
+    'gezel-native-0.1.54-linux-x64-cpu.tar.gz': '57de7d52b0e95e3886bf4ffad7e015b98ba8bbea96b95d8cb3e26bc1ff309e99',
+    'gezel-native-0.1.54-linux-x64-cuda.tar.gz': 'c2d8616410f72b8bb217194f7c71d5175ed1c94ac6d9d94f660e0f535a3cff22',
+    'gezel-native-0.1.54-linux-x64-vulkan.tar.gz': '89f3233f41861404db082219962eb25d1b2c3f6e42bbc2696fda122ce845371d',
+    'gezel-native-0.1.54-linux-x64.tar.gz': 'f42e42d71187c6ef5af9685ebb65511bb7ac638815105f09f3df22cfdb9e6bce',
+    'gezel-native-0.1.54-win32-arm64-cpu.zip': 'e482e2af92f28135aea2e21ae97290e231b0dc77eadc8cc532d2506304d27575',
+    'gezel-native-0.1.54-win32-arm64-cuda.zip': 'ff6eaf7f070e9aba7fc087a155896f73b12664d867e0374af5546e941c153b82',
+    'gezel-native-0.1.54-win32-arm64.zip': '9b854d824117fe56d7d532ab83c01693a97cf6b45752e69cb895aa183c8cff35',
+    'gezel-native-0.1.54-win32-x64-cpu.zip': '93c8f22b47831ba8e0808033e87ce91cdb0d481890602857b6b8b5295cc7d50b',
+    'gezel-native-0.1.54-win32-x64-cuda.zip': '84da0b362e502d0bb6e3509528e7a4ccff50c2b9fcaa2fa1a62b3d9b0ad9f5d2',
+    'gezel-native-0.1.54-win32-x64-vulkan.zip': '1a3c99ce8343552fb17af80c36ba8ebb7c13ac8d6b4966f3aa3054018d41fa11',
+    'gezel-native-0.1.54-win32-x64.zip': 'f224fcdea6945ce574d32bee6ace345f82847f317c40cfa9059feba9b87ac0ca',
 });
-/** Download size in bytes of every engine archive published by native-v0.1.51. */
+/** Download size in bytes of every engine archive published by native-v0.1.54. */
 export const NATIVE_ENGINE_ARCHIVE_BYTES = Object.freeze({
-    'gezel-native-0.1.51-darwin-arm64-metal.tar.gz': 7056609,
-    'gezel-native-0.1.51-darwin-arm64.tar.gz': 41556782,
-    'gezel-native-0.1.51-linux-arm64-cpu.tar.gz': 8836261,
-    'gezel-native-0.1.51-linux-arm64-cuda.tar.gz': 619480627,
-    'gezel-native-0.1.51-linux-arm64.tar.gz': 41979458,
-    'gezel-native-0.1.51-linux-x64-cpu.tar.gz': 12914417,
-    'gezel-native-0.1.51-linux-x64-cuda.tar.gz': 989771250,
-    'gezel-native-0.1.51-linux-x64-vulkan.tar.gz': 25672179,
-    'gezel-native-0.1.51-linux-x64.tar.gz': 58057226,
-    'gezel-native-0.1.51-win32-arm64-cpu.zip': 5618599,
-    'gezel-native-0.1.51-win32-arm64.zip': 42055408,
-    'gezel-native-0.1.51-win32-x64-cpu.zip': 8714418,
-    'gezel-native-0.1.51-win32-x64-cuda.zip': 749850276,
-    'gezel-native-0.1.51-win32-x64-vulkan.zip': 21123169,
-    'gezel-native-0.1.51-win32-x64.zip': 56558016,
+    'gezel-native-0.1.54-darwin-arm64-metal.tar.gz': 7056387,
+    'gezel-native-0.1.54-darwin-arm64.tar.gz': 42224129,
+    'gezel-native-0.1.54-linux-arm64-cpu.tar.gz': 8838944,
+    'gezel-native-0.1.54-linux-arm64-cuda.tar.gz': 620429935,
+    'gezel-native-0.1.54-linux-arm64.tar.gz': 42037092,
+    'gezel-native-0.1.54-linux-x64-cpu.tar.gz': 12914025,
+    'gezel-native-0.1.54-linux-x64-cuda.tar.gz': 993587032,
+    'gezel-native-0.1.54-linux-x64-vulkan.tar.gz': 25672135,
+    'gezel-native-0.1.54-linux-x64.tar.gz': 57185943,
+    'gezel-native-0.1.54-win32-arm64-cpu.zip': 5623741,
+    'gezel-native-0.1.54-win32-arm64-cuda.zip': 242341587,
+    'gezel-native-0.1.54-win32-arm64.zip': 42236457,
+    'gezel-native-0.1.54-win32-x64-cpu.zip': 8719660,
+    'gezel-native-0.1.54-win32-x64-cuda.zip': 749849595,
+    'gezel-native-0.1.54-win32-x64-vulkan.zip': 21128362,
+    'gezel-native-0.1.54-win32-x64.zip': 55668353,
 });
 // END PINNED NATIVE ARCHIVE HASHES
 /**

package/dist/engines/resolver.js

@@ -755,6 +755,15 @@ function stampEnv(engine, binPath, variant, versionDir) {
     process.env.GEZEL_NATIVE_BIN_DIR = versionDir;
     if (engine === 'llama-server' && variant)
         process.env.GEZEL_LLAMA_SERVER_BACKEND = variant;
+    // Windows on ARM's bare archive also carries sqlite-vec, which npm has no
+    // build of there. The sqlite driver reads this on every database open, so
+    // vector search starts with the next query rather than the next boot.
+    const platformKey = resolvePlatformKey();
+    const ext = process.platform === 'win32' ? 'dll' : process.platform === 'darwin' ? 'dylib' : 'so';
+    const sqliteVec = platformKey ? join(versionDir, platformKey, `vec0.${ext}`) : null;
+    if (sqliteVec && !process.env.GEZEL_SQLITE_VEC_PATH && existsSync(sqliteVec)) {
+        process.env.GEZEL_SQLITE_VEC_PATH = sqliteVec;
+    }
 }
 async function resolveGitHubToken() {
     if (process.env.GEZEL_GITHUB_TOKEN)
@@ -763,7 +772,9 @@ async function resolveGitHubToken() {
         return process.env.GITHUB_TOKEN;
     try {
         const { execFileSync } = await import('node:child_process');
-        const out = execFileSync('gh', ['auth', 'token'], {
+        // Named host: a bare `gh auth token` answers for gh's default host, which
+        // can be a GitHub Enterprise server whose token must not go to github.com.
+        const out = execFileSync('gh', ['auth', 'token', '--hostname', 'github.com'], {
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'ignore'],
             ...windowsHeadlessSpawnOptions(),

package/dist/fs/atomic.d.ts

@@ -50,4 +50,7 @@ export declare function writeFileAtomic(absPath: string, content: string | Uint8
  * private staging file by their adapter, then copied to a sibling temporary
  * path and renamed into place.
  */
-export declare function copyFileAtomic(sourcePath: string, absPath: string): Promise<void>;
+export declare function copyFileAtomic(sourcePath: string, absPath: string, opts?: {
+    noReplace?: boolean;
+    signal?: AbortSignal;
+}): Promise<void>;

package/dist/fs/atomic.js

@@ -108,10 +108,16 @@ export async function writeFileAtomic(absPath, content, opts) {
  * private staging file by their adapter, then copied to a sibling temporary
  * path and renamed into place.
  */
-export async function copyFileAtomic(sourcePath, absPath) {
+export async function copyFileAtomic(sourcePath, absPath, opts) {
     const tmp = `${absPath}.tmp-${process.pid}-${randomUUID()}`;
     try {
         await copyFile(sourcePath, tmp);
+        opts?.signal?.throwIfAborted();
+        if (opts?.noReplace) {
+            await link(tmp, absPath);
+            await rm(tmp, { force: true }).catch(() => undefined);
+            return;
+        }
         await renameWithWindowsRetry(tmp, absPath);
     }
     catch (err) {

package/dist/http/openai-compat/chat-target.d.ts

@@ -59,7 +59,7 @@ export declare function resolvePinnedModelTarget(ctx: ServiceContext, model: str
  * Pick the gezel that guarantees a persona-backed fallback for public
  * inference requests.
  *
- * The explicit Connected Apps choice wins. When it is unset or stale,
+ * The explicit Integrations choice wins. When it is unset or stale,
  * the install's Meester is the natural front door; the first available
  * gezel is the final recovery path for older or partially migrated
  * homes. A healthy store always has at least a Meester, but returning

package/dist/http/openai-compat/chat-target.js

@@ -29,7 +29,7 @@ export async function resolvePinnedModelTarget(ctx, model) {
  * Pick the gezel that guarantees a persona-backed fallback for public
  * inference requests.
  *
- * The explicit Connected Apps choice wins. When it is unset or stale,
+ * The explicit Integrations choice wins. When it is unset or stale,
  * the install's Meester is the natural front door; the first available
  * gezel is the final recovery path for older or partially migrated
  * homes. A healthy store always has at least a Meester, but returning

package/dist/http/openai-compat/engine-failure.js

@@ -53,10 +53,15 @@ function internalCode(err) {
         const code = current.code;
         const wire = typeof code === 'string' ? WIRE_CODES.get(code) : undefined;
         // A crash the out-of-memory killer caused is a capacity fact, not a fault.
-        if (wire === 'engine_crashed' &&
-            current.panicKind === 'host-out-of-memory') {
+        const panicKind = current.panicKind;
+        if (wire === 'engine_crashed' && panicKind === 'host-out-of-memory') {
             return 'engine_out_of_memory';
         }
+        // A runtime the machine lacks: the engine never started, and retrying
+        // cannot help until it is installed.
+        if (wire === 'engine_crashed' && panicKind === 'missing-runtime') {
+            return 'engine_launch_failed';
+        }
         if (wire)
             return wire;
         current = current.cause;

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

@@ -289,7 +289,7 @@ export function v1ChatRoutes(ctx, opts = {}) {
             // instruct folds, per-gezel overrides for gezel: targets) applies
             // unconditionally — it's "what the model is" — with the caller's
             // per-request knobs overlaid on top. The behavior `profile` is the
-            // supporting layer the Connected Apps switch gates. Caller-owned
+            // supporting layer the Integrations switch gates. Caller-owned
             // inference keeps parsing, grammar, and transcript compatibility but
             // omits interventions which assume Gezel owns the action loop.
             // Best-effort: a resolver failure serves engine defaults rather than

package/dist/http/routes/v1-images.d.ts

@@ -0,0 +1,44 @@
+import { type GezelConfig } from '@bendyline/gezel';
+import type { CatalogService } from '@bendyline/gezel-catalog';
+import { Hono } from 'hono';
+import type { ImageModelPullRegistry } from '../../providers/image/pull-registry.js';
+import { type ImageProvider } from '../../providers/image/types.js';
+export interface ImagesRouteContext {
+    home: string;
+    catalog: CatalogService;
+    store: {
+        readConfig(): Promise<GezelConfig>;
+    };
+    images: {
+        /** Whether an engine can render here at all. */
+        available(): boolean;
+        current(): Promise<ImageProvider>;
+        /** Stop the engine, draining renders, before its model files change. */
+        reset(): Promise<void>;
+        pulls: ImageModelPullRegistry;
+    };
+}
+/**
+ * `/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 declare function v1ImagesRoutes(ctx: ImagesRouteContext): Hono;

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-knowledge.js

@@ -222,6 +222,10 @@ export function v1KnowledgeRoutes(ctx) {
             maxResults: 24,
             queryEmbedBudgetMs: 5000,
             catalogs: enabled.map((entry) => entry.ref.catalogId),
+            // Let the reranker choose among an article's sections: one passage per
+            // article, picked by embedding similarity, sent an infobox in place of
+            // the history the person asked about.
+            chunksPerDocument: 3,
         });
         c.req.raw.signal.throwIfAborted();
         const candidates = [];

package/dist/http/routes/v1-responses.d.ts

@@ -9,7 +9,7 @@ import type { InferenceContext } from '../inference-context.js';
  * and returns assistant text/tool calls in Responses wire shapes. The route
  * intentionally does not create a Gezel chat session or attach Gezel MCP.
  *
- * In the full service, auth is mounted in `server.ts`: the Connected Apps
+ * In the full service, auth is mounted in `server.ts`: the Integrations
  * master switch, bearer authentication, and the `openai` scope all apply. Codex can therefore use
  * an app-scoped token without ever learning the daemon's root credential.
  */