@qvac/harness 0.3.3 → 0.5.0

package/dist-lib/lib/models/idle-unload.js

@@ -0,0 +1,51 @@
+import { raceTimeout } from '../helpers/race-timeout.js';
+const DEFAULT_TICK_MS = 60_000;
+export function createIdleReaper({ sweep, waitMs, onError, now = Date.now, tickMs = DEFAULT_TICK_MS }) {
+    let timeoutMs = 0;
+    let inflight = 0;
+    let lastActivity = now();
+    let sweeping = null;
+    let timer = null;
+    const tick = () => {
+        if (sweeping !== null || inflight > 0 || now() - lastActivity < timeoutMs) {
+            return;
+        }
+        const run = sweep().catch(onError).catch(noop);
+        sweeping = raceTimeout(run, { ms: waitMs, fallback: undefined }).finally(() => {
+            sweeping = null;
+            lastActivity = now();
+        });
+    };
+    const disarm = () => {
+        if (timer !== null) {
+            clearInterval(timer);
+        }
+        timer = null;
+    };
+    return {
+        configure(ms) {
+            timeoutMs = ms;
+            disarm();
+            if (ms <= 0) {
+                return;
+            }
+            timer = setInterval(tick, Math.min(tickMs, ms));
+            if (typeof timer.unref === 'function') {
+                timer.unref();
+            }
+        },
+        async enter() {
+            inflight++;
+            lastActivity = now();
+            if (sweeping !== null) {
+                await sweeping;
+            }
+        },
+        exit() {
+            inflight--;
+            lastActivity = now();
+        },
+        close: disarm
+    };
+}
+function noop() { }

package/dist-lib/lib/models/kv-cache.d.ts

@@ -1,4 +1,5 @@
-export declare function adrenoSafeKvCache(device: 'cpu' | 'gpu' | undefined, requestedK: string | undefined, requestedV: string | undefined, hostPlatform?: string): {
+export interface KvCacheTypes {
     k: string | undefined;
     v: string | undefined;
-};
+}
+export declare function adrenoSafeKvCache(device: 'cpu' | 'gpu' | undefined, { k, v }: KvCacheTypes, hostPlatform?: string): KvCacheTypes;

package/dist-lib/lib/models/kv-cache.js

@@ -1,6 +1,7 @@
 import { platform } from 'os';
-export function adrenoSafeKvCache(device, requestedK, requestedV, hostPlatform = platform()) {
-    if (device === 'cpu' || hostPlatform !== 'android')
-        return { k: requestedK, v: requestedV };
+export function adrenoSafeKvCache(device, { k, v }, hostPlatform = platform()) {
+    if (device === 'cpu' || hostPlatform !== 'android') {
+        return { k, v };
+    }
     return { k: 'f16', v: 'f16' };
 }

package/dist-lib/lib/models/llm-presets.d.ts

@@ -1,4 +1,4 @@
-export type LlmGenerationParams = {
+export interface LlmGenerationParams {
     temp?: number;
     top_p?: number;
     top_k?: number;
@@ -6,5 +6,5 @@ export type LlmGenerationParams = {
     repeat_penalty?: number;
     frequency_penalty?: number;
     reasoning_budget: -1 | 0;
-};
+}
 export declare function resolveLlmGenerationParams(modelName: string | undefined, reasoningEnabled: boolean | undefined, deviceDefault?: boolean): LlmGenerationParams | undefined;

package/dist-lib/lib/models/llm-presets.js

@@ -31,11 +31,13 @@ export function resolveLlmGenerationParams(modelName, reasoningEnabled, deviceDe
     const resolver = modelName
         ? PRESET_RESOLVERS.find((entry) => modelName.startsWith(entry.prefix))
         : undefined;
-    if (resolver)
+    if (resolver) {
         return resolver.resolve(reasoningEnabled);
+    }
     const effective = reasoningEnabled ?? deviceDefault;
-    if (effective === undefined)
+    if (effective === undefined) {
         return undefined;
+    }
     return { reasoning_budget: effective ? -1 : 0 };
 }
 function qwen08BPreset(reasoningEnabled) {

package/dist-lib/lib/models/model-catalog-constants.js

@@ -14,7 +14,7 @@ export const QWEN_38_27B = 'Qwen3.8-27B-UD-Q4_K_XL';
 export const MEDPSY_1_7B = 'medpsy-1.7b-q4_k_m-imat';
 export const MEDPSY_4B = 'medpsy-4b-q4_k_m-imat';
 export function isCapabilityProfile(value) {
-    return CAPABILITY_PROFILE_ORDER.includes(value);
+    return CAPABILITY_PROFILE_ORDER.some((profile) => profile === value);
 }
 export function meetsMinCapabilityProfile(active, required) {
     return CAPABILITY_PROFILE_ORDER.indexOf(active) >= CAPABILITY_PROFILE_ORDER.indexOf(required);
@@ -41,8 +41,9 @@ const PROFILE_TO_MODEL_NAME = new Map([
 ]);
 export function capabilityProfileToModelName(profile) {
     const name = PROFILE_TO_MODEL_NAME.get(profile);
-    if (!name)
+    if (!name) {
         throw new Error(`no model for capability profile ${profile}`);
+    }
     return name;
 }
 export const AGENT_MODEL_NAMES = [

package/dist-lib/lib/models/model-catalog.d.ts

@@ -1,4 +1,6 @@
 import type { ModelRegistryEntry, ToolDialect } from '@qvac/sdk';
+import type { ImageModelSet } from '../tools/generate-image.ts';
+import type { MusicModelStages } from '../tools/generate-music.ts';
 import type { ModelAddon } from './model-source.ts';
 export interface SdkModelAsset extends ModelRegistryEntry {
     readonly src: string;
@@ -24,10 +26,11 @@ export interface CategoryDefault {
 export declare const CATEGORY_DEFAULTS: ReadonlyArray<CategoryDefault>;
 export declare function defaultVoiceModel(category: ModelCategory): string;
 export declare function defaultTtsFor(profile: CapabilityProfile): CategoryDefault;
-export declare function infraModelsFor(profile: CapabilityProfile): Array<{
-    name: string;
-    addon: ModelAddon;
-}>;
+export interface CatalogModel {
+    readonly name: string;
+    readonly addon: ModelAddon;
+}
+export declare function infraModelsFor(profile: CapabilityProfile): CatalogModel[];
 export declare function mediaModelNameFor(category: ModelCategory, profile: CapabilityProfile): string;
 export interface DiffusionCatalogEntry {
     readonly choice: ImageModelChoice;
@@ -62,12 +65,7 @@ export declare const AUDIOGEN_CATALOG: ReadonlyArray<AudioGenCatalogEntry>;
 export declare function musicDefaultSteps(choice: string | undefined): number | undefined;
 export declare function musicChoiceForDit(dit: string): MusicModelChoice | undefined;
 export declare function musicSizeBytes(entry: AudioGenCatalogEntry): number;
-export declare function musicModelSet(choice: string | undefined): {
-    dit: string;
-    textEnc: string;
-    lm: string;
-    vae: string;
-} | null;
+export declare function musicModelSet(choice: string | undefined): MusicModelStages | null;
 export interface AudioGenDownloadMetadata {
     readonly companions: ReadonlyArray<string>;
     readonly assetSizes: Readonly<Record<string, number>>;
@@ -80,17 +78,9 @@ export interface AgentSkillModelInput {
     readonly imageModelChoice?: ImageModelChoice | null;
     readonly musicModelChoice?: MusicModelChoice | null;
 }
-export declare function skillModelsForAgent(agent: AgentSkillModelInput): ReadonlyArray<{
-    readonly name: string;
-    readonly addon: ModelAddon;
-}>;
+export declare function skillModelsForAgent(agent: AgentSkillModelInput): ReadonlyArray<CatalogModel>;
 export declare function diffusionSizeBytes(entry: DiffusionCatalogEntry): number;
-export declare function imageModelFor(choice: string | undefined): {
-    model: string;
-    llmModel?: string | undefined;
-    vaeModel?: string | undefined;
-    prediction?: 'flux2_flow' | undefined;
-} | null;
+export declare function imageModelFor(choice: string | undefined): ImageModelSet | null;
 export interface ImageClamps {
     maxDim?: number;
     maxSteps?: number;
@@ -105,13 +95,21 @@ export interface CuratedListable {
 }
 export declare function curatedListables(): CuratedListable[];
 export declare function curatedModelAsset(name: string, addon: ModelRegistryEntry['addon']): SdkModelAsset | undefined;
+export declare const CUSTOM_TASK_TYPES: readonly ['llm'];
+export type CustomTaskType = (typeof CUSTOM_TASK_TYPES)[number];
 export interface CustomModelEntry {
     readonly name: string;
     readonly src: string;
     readonly projectionSrc?: string;
+    readonly taskType?: CustomTaskType;
+    readonly expectedSize?: number;
+    readonly label?: string;
+    readonly contextLength?: number;
 }
 export declare function setCustomModels(entries: ReadonlyArray<CustomModelEntry>): void;
-export declare function customModelSrc(name: string): string | undefined;
+export declare function customModels(): ReadonlyArray<CustomModelEntry>;
+export declare function customContextLength(name: string): number | undefined;
+export declare function customModelSrc(name: string, addon: ModelRegistryEntry['addon']): string | undefined;
 export declare function customToolDialect(name: string): ToolDialect | undefined;
 export declare function customProjectionMap(): Record<string, string>;
 export declare function companionRegistryPaths(): Map<string, string[]>;

package/dist-lib/lib/models/model-catalog.js

@@ -56,8 +56,9 @@ export const LLM_CATALOG = [
 export function defaultProjectionMap() {
     const map = {};
     for (const entry of LLM_CATALOG) {
-        if (entry.projection)
+        if (entry.projection) {
             map[entry.name] = entry.projection.src;
+        }
     }
     return map;
 }
@@ -73,13 +74,18 @@ export const CATEGORY_DEFAULTS = [
 ];
 export function defaultVoiceModel(category) {
     const entry = CATEGORY_DEFAULTS.find((candidate) => candidate.category === category);
-    if (!entry)
+    if (!entry) {
         throw new Error(`no default model for category ${category}`);
+    }
     return entry.asset.src;
 }
 export function defaultTtsFor(profile) {
     const name = defaultTtsModelName(profile);
-    return CATEGORY_DEFAULTS.find((entry) => entry.name === name);
+    const entry = CATEGORY_DEFAULTS.find((candidate) => candidate.name === name);
+    if (!entry) {
+        throw new Error(`no default tts model named ${name}`);
+    }
+    return entry;
 }
 export function infraModelsFor(profile) {
     const tts = defaultTtsFor(profile);
@@ -87,11 +93,13 @@ export function infraModelsFor(profile) {
     return [tts, ...rest].map((entry) => ({ name: entry.name, addon: entry.asset.addon }));
 }
 export function mediaModelNameFor(category, profile) {
-    if (category === 'tts')
+    if (category === 'tts') {
         return defaultTtsFor(profile).name;
+    }
     const entry = CATEGORY_DEFAULTS.find((candidate) => candidate.category === category);
-    if (!entry)
+    if (!entry) {
         throw new Error(`no default model for category ${category}`);
+    }
     return entry.name;
 }
 const IMAGE_GENERATION_SKILL = 'image-generation';
@@ -123,10 +131,12 @@ export const DIFFUSION_CATALOG = [
 ];
 function diffusionAssets(entry) {
     const assets = [entry.model];
-    if (entry.llmModel)
+    if (entry.llmModel) {
         assets.push(entry.llmModel);
-    if (entry.vaeModel)
+    }
+    if (entry.vaeModel) {
         assets.push(entry.vaeModel);
+    }
     return assets;
 }
 function diffusionCatalogEntry(model) {
@@ -142,12 +152,14 @@ export function diffusionDownloadMetadata(model, addon) {
     if (addon !== 'diffusion')
         return undefined;
     const entry = diffusionCatalogEntry(model);
-    if (!entry)
+    if (!entry) {
         return undefined;
+    }
     const assets = diffusionAssets(entry);
     const assetSizes = {};
-    for (const asset of assets)
+    for (const asset of assets) {
         assetSizes[asset.src] = asset.expectedSize;
+    }
     return {
         companions: assets.slice(1).map((asset) => asset.src),
         assetSizes
@@ -202,8 +214,9 @@ export function musicSizeBytes(entry) {
 }
 export function musicModelSet(choice) {
     const entry = AUDIOGEN_CATALOG.find((candidate) => candidate.choice === choice);
-    if (!entry)
+    if (!entry) {
         return null;
+    }
     return {
         dit: entry.dit.src,
         textEnc: entry.textEnc.src,
@@ -215,12 +228,14 @@ export function audioGenDownloadMetadata(model, addon) {
     if (addon !== 'audiogen')
         return undefined;
     const entry = AUDIOGEN_CATALOG.find((candidate) => candidate.name === model || candidate.dit.name === model || candidate.dit.src === model);
-    if (!entry)
+    if (!entry) {
         return undefined;
+    }
     const stages = audioGenStages(entry);
     const assetSizes = {};
-    for (const asset of stages)
+    for (const asset of stages) {
         assetSizes[asset.src] = asset.expectedSize;
+    }
     return {
         companions: stages.slice(1).map((asset) => asset.src),
         assetSizes
@@ -235,14 +250,16 @@ export function skillModelsForAgent(agent) {
     if (agentHasSkill(agent, IMAGE_GENERATION_SKILL)) {
         const choice = agent.imageModelChoice ?? DEFAULT_IMAGE_MODEL_CHOICE;
         const entry = DIFFUSION_CATALOG.find((candidate) => candidate.choice === choice);
-        if (entry)
+        if (entry) {
             models.push({ name: entry.name, addon: entry.model.addon });
+        }
     }
     if (agentHasSkill(agent, MUSIC_GENERATION_SKILL)) {
         const choice = agent.musicModelChoice ?? DEFAULT_MUSIC_MODEL_CHOICE;
         const entry = AUDIOGEN_CATALOG.find((candidate) => candidate.choice === choice);
-        if (entry)
+        if (entry) {
             models.push({ name: entry.name, addon: entry.dit.addon });
+        }
     }
     return models;
 }
@@ -251,13 +268,14 @@ export function diffusionSizeBytes(entry) {
 }
 export function imageModelFor(choice) {
     const entry = DIFFUSION_CATALOG.find((candidate) => candidate.choice === choice);
-    if (!entry)
+    if (!entry) {
         return null;
+    }
     return {
         model: entry.model.src,
-        ...(entry.llmModel ? { llmModel: entry.llmModel.src } : {}),
-        ...(entry.vaeModel ? { vaeModel: entry.vaeModel.src } : {}),
-        ...(entry.prediction ? { prediction: entry.prediction } : {})
+        llmModel: entry.llmModel?.src,
+        vaeModel: entry.vaeModel?.src,
+        prediction: entry.prediction
     };
 }
 export function imageClampsFromEnv(env) {
@@ -267,9 +285,10 @@ export function imageClampsFromEnv(env) {
     };
     const maxDim = positive(env.QVAC_IMAGE_MAX_DIM);
     const maxSteps = positive(env.QVAC_IMAGE_MAX_STEPS);
-    if (!maxDim && !maxSteps)
+    if (!maxDim && !maxSteps) {
         return undefined;
-    return { ...(maxDim ? { maxDim } : {}), ...(maxSteps ? { maxSteps } : {}) };
+    }
+    return { maxDim, maxSteps };
 }
 export function imageModelFromEnv(env, onIgnoredCompanions, onIgnoredPrediction) {
     const catalog = imageModelFor(env.QVAC_IMAGE_MODEL);
@@ -279,12 +298,14 @@ export function imageModelFromEnv(env, onIgnoredCompanions, onIgnoredPrediction)
         }
         return catalog;
     }
-    if (!env.QVAC_IMAGE_MODEL)
+    if (!env.QVAC_IMAGE_MODEL) {
         return undefined;
+    }
     const prediction = env.QVAC_IMAGE_PREDICTION || undefined;
     const fluxSet = Boolean(env.QVAC_IMAGE_LLM && env.QVAC_IMAGE_VAE);
-    if (prediction && !fluxSet)
+    if (prediction && !fluxSet) {
         onIgnoredPrediction?.();
+    }
     return {
         model: env.QVAC_IMAGE_MODEL,
         llmModel: env.QVAC_IMAGE_LLM || undefined,
@@ -304,44 +325,55 @@ export function curatedListables() {
         ...DIFFUSION_CATALOG.map((entry) => ({
             name: entry.name,
             asset: entry.model,
-            companions: [entry.llmModel, entry.vaeModel].filter(Boolean)
+            companions: [entry.llmModel, entry.vaeModel].filter((asset) => asset !== undefined)
         }))
     ];
 }
 export function curatedModelAsset(name, addon) {
     return curatedListables().find((entry) => entry.asset.addon === addon && (entry.name === name || entry.asset.name === name))?.asset;
 }
+export const CUSTOM_TASK_TYPES = ['llm'];
 let CUSTOM_MODELS = new Map();
 export function setCustomModels(entries) {
     CUSTOM_MODELS = new Map(entries.map((entry) => [entry.name, entry]));
 }
-export function customModelSrc(name) {
-    return CUSTOM_MODELS.get(name)?.src;
+export function customModels() {
+    return [...CUSTOM_MODELS.values()];
+}
+export function customContextLength(name) {
+    return CUSTOM_MODELS.get(name)?.contextLength;
+}
+export function customModelSrc(name, addon) {
+    const entry = CUSTOM_MODELS.get(name);
+    return entry && (entry.taskType ?? 'llm') === addon ? entry.src : undefined;
 }
 export function customToolDialect(name) {
     const entry = CUSTOM_MODELS.get(name);
-    return entry ? detectToolDialect(entry.src, entry.name) : undefined;
+    return entry
+        ? detectToolDialect(entry.src, entry.label?.replace(/\s+/g, '-') ?? entry.name)
+        : undefined;
 }
 export function customProjectionMap() {
     const map = {};
     for (const entry of CUSTOM_MODELS.values()) {
-        if (entry.projectionSrc)
+        if (entry.projectionSrc) {
             map[entry.name] = entry.projectionSrc;
+        }
     }
     return map;
 }
 export function companionRegistryPaths() {
     const map = new Map();
     for (const entry of LLM_CATALOG) {
-        if (entry.projection)
+        if (entry.projection) {
             map.set(entry.weight.registryPath, [entry.projection.registryPath]);
+        }
     }
     for (const entry of DIFFUSION_CATALOG) {
-        const companions = [entry.llmModel, entry.vaeModel]
-            .filter(Boolean)
-            .map((asset) => asset.registryPath);
-        if (companions.length)
+        const companions = [entry.llmModel, entry.vaeModel].flatMap((asset) => asset ? [asset.registryPath] : []);
+        if (companions.length) {
             map.set(entry.model.registryPath, companions);
+        }
     }
     for (const entry of AUDIOGEN_CATALOG) {
         map.set(entry.dit.registryPath, [
@@ -355,8 +387,9 @@ export function companionRegistryPaths() {
 export function audioGenModelByName(name) {
     for (const entry of AUDIOGEN_CATALOG) {
         for (const stage of [entry.dit, entry.textEnc, entry.lm, entry.vae]) {
-            if (stage.name === name || entry.name === name)
+            if (stage.name === name || entry.name === name) {
                 return name === entry.name ? entry.dit : stage;
+            }
         }
     }
     return undefined;

package/dist-lib/lib/models/model-delete.d.ts

@@ -15,4 +15,7 @@ export interface DeleteModelSummary {
     readonly freedBytes: number;
 }
 export declare function summarizeDelete(result: DeleteModelResult): DeleteModelSummary;
-export declare function deleteModelFiles(sdk: ModelDeleteSdk, name: string): Promise<DeleteModelResult>;
+export interface DeleteModelOptions {
+    readonly modelsDir?: string;
+}
+export declare function deleteModelFiles(sdk: ModelDeleteSdk, name: string, { modelsDir }?: DeleteModelOptions): Promise<DeleteModelResult>;

package/dist-lib/lib/models/model-delete.js

@@ -1,27 +1,40 @@
 import fs from 'fs';
-import { curatedListables, musicListables } from './model-catalog.js';
+import { customDownloads } from './custom-model-cache.js';
+import { curatedListables, customModels, musicListables } from './model-catalog.js';
 export function summarizeDelete(result) {
     return { name: result.name, removed: result.removed.length, freedBytes: result.freedBytes };
 }
-export async function deleteModelFiles(sdk, name) {
-    const seen = new Set();
+export async function deleteModelFiles(sdk, name, { modelsDir } = {}) {
+    const custom = customModels().find((entry) => entry.name === name);
+    const { files, dirs } = custom
+        ? await customDownloads(custom, modelsDir)
+        : { files: await catalogFiles(sdk, name), dirs: [] };
     const removed = [];
+    for (const filePath of new Set(files)) {
+        const bytes = await onDiskSize(filePath);
+        if (bytes === null) {
+            continue;
+        }
+        await fs.promises.rm(filePath, { force: true });
+        removed.push({ path: filePath, bytes });
+    }
+    for (const dir of dirs) {
+        await fs.promises.rm(dir, { recursive: true, force: true });
+    }
+    return { name, removed, freedBytes: removed.reduce((sum, file) => sum + file.bytes, 0) };
+}
+async function catalogFiles(sdk, name) {
+    const paths = [];
     for (const catalogName of namesToPurge(name)) {
         const info = await sdk.getModelInfo({ name: catalogName }).catch(() => null);
-        if (!info)
+        if (!info) {
             continue;
+        }
         for (const file of info.cacheFiles) {
-            if (seen.has(file.path))
-                continue;
-            seen.add(file.path);
-            const bytes = await onDiskSize(file.path);
-            if (bytes === null)
-                continue;
-            await fs.promises.rm(file.path, { force: true });
-            removed.push({ path: file.path, bytes });
+            paths.push(file.path);
         }
     }
-    return { name, removed, freedBytes: removed.reduce((sum, file) => sum + file.bytes, 0) };
+    return paths;
 }
 async function onDiskSize(filePath) {
     try {
@@ -36,12 +49,14 @@ function namesToPurge(name) {
     const curated = curatedListables().find((entry) => entry.name === name || entry.asset.name === name);
     if (curated) {
         const names = [curated.asset.name, ...curated.companions.map((companion) => companion.name)];
-        if (curated.projection)
+        if (curated.projection) {
             names.push(curated.projection.name);
+        }
         return names;
     }
     const music = musicListables().find((entry) => entry.name === name || entry.asset.name === name);
-    if (music)
+    if (music) {
         return [music.asset.name, ...music.companions.map((stage) => stage.name)];
+    }
     return [name];
 }

package/dist-lib/lib/models/model-handle.js

@@ -16,8 +16,9 @@ export class ModelHandle {
             this._tracked = attempt;
             this._loading = true;
             const settled = () => {
-                if (this._tracked === attempt)
+                if (this._tracked === attempt) {
                     this._loading = false;
+                }
             };
             attempt.then(settled, settled);
         }

package/dist-lib/lib/models/model-list.d.ts

@@ -18,6 +18,7 @@ export interface ModelInfo {
     supportsImages: boolean;
     expectedSize: number;
     actualSize?: number;
+    label?: string;
 }
 export interface ListModelsOptions {
     type?: ModelType;
@@ -31,12 +32,22 @@ interface ModelStatus {
     expectedSize?: number;
     actualSize?: number;
 }
-export type ModelStatusCache = {
+export interface ModelStatusCache {
     readonly entries: Map<string, ModelStatus>;
     epoch: number;
-};
+}
 export declare const MODEL_STATUS_TTL_MS = 30000;
 export declare function createModelStatusCache(): ModelStatusCache;
 export declare function invalidateModelStatusCache(cache: ModelStatusCache): void;
-export declare function listModels(sdk: ModelListSdk, { type, cachedOnly, fullRegistry }?: ListModelsOptions, cache?: ModelStatusCache, projectionFor?: (name: string) => string | undefined): Promise<ModelInfo[]>;
+export interface ListModelsRuntime {
+    cache?: ModelStatusCache | undefined;
+    projectionFor?: ((name: string) => string | undefined) | undefined;
+}
+export declare function listModels(sdk: ModelListSdk, { type, cachedOnly, fullRegistry }?: ListModelsOptions, { cache, projectionFor }?: ListModelsRuntime): Promise<ModelInfo[]>;
+export interface CustomModelRowsContext {
+    readonly modelsDir?: string;
+    readonly loaded: ReadonlySet<string>;
+}
+export declare function customModelRows({ type, cachedOnly }: ListModelsOptions, { modelsDir, loaded }: CustomModelRowsContext): Promise<ModelInfo[]>;
+export declare function mergeCustomRows(catalog: ReadonlyArray<ModelInfo>, custom: ReadonlyArray<ModelInfo>): ModelInfo[];
 export {};

package/dist-lib/lib/models/model-list.js

@@ -1,4 +1,5 @@
-import { companionRegistryPaths, curatedListables, musicListables } from './model-catalog.js';
+import { isCustomModelCached } from './custom-model-cache.js';
+import { companionRegistryPaths, curatedListables, customModels, musicListables } from './model-catalog.js';
 export const MODEL_STATUS_TTL_MS = 30_000;
 export function createModelStatusCache() {
     return { entries: new Map(), epoch: 0 };
@@ -14,8 +15,9 @@ async function mapPool(items, limit, fn) {
     const worker = async () => {
         while (true) {
             const i = cursor++;
-            if (i >= items.length)
+            if (i >= items.length) {
                 return;
+            }
             results[i] = await fn(items[i]);
         }
     };
@@ -45,13 +47,14 @@ async function musicRows(hydrate) {
     }
     return rows;
 }
-export async function listModels(sdk, { type, cachedOnly, fullRegistry } = {}, cache, projectionFor) {
+export async function listModels(sdk, { type, cachedOnly, fullRegistry } = {}, { cache, projectionFor } = {}) {
     const now = Date.now();
     const seesImages = (name, addon) => addon === 'llm' && Boolean(projectionFor?.(name));
     const hydrate = async (registryPath, catalogName) => {
         const hit = cache?.entries.get(registryPath);
-        if (hit && now - hit.at < MODEL_STATUS_TTL_MS)
+        if (hit && now - hit.at < MODEL_STATUS_TTL_MS) {
             return hit;
+        }
         const epoch = cache?.epoch;
         const info = catalogName
             ? await sdk.getModelInfo({ name: catalogName }).catch(() => null)
@@ -63,8 +66,9 @@ export async function listModels(sdk, { type, cachedOnly, fullRegistry } = {}, c
             expectedSize: info?.expectedSize,
             actualSize: info?.actualSize
         };
-        if (cache && cache.epoch === epoch)
+        if (cache && cache.epoch === epoch) {
             cache.entries.set(registryPath, status);
+        }
         return status;
     };
     if (!fullRegistry) {
@@ -98,8 +102,9 @@ export async function listModels(sdk, { type, cachedOnly, fullRegistry } = {}, c
     }
     const entries = await sdk.modelRegistrySearch(type ? { addon: type } : {});
     const catalog = new Map();
-    for (const c of sdk.models)
+    for (const c of sdk.models) {
         catalog.set(c.registryPath, c.name);
+    }
     const rows = await mapPool(entries, STATUS_CONCURRENCY, async (entry) => {
         const status = await hydrate(entry.registryPath, catalog.get(entry.registryPath));
         const companions = COMPANIONS_BY_WEIGHT.get(entry.registryPath) ?? [];
@@ -121,3 +126,25 @@ export async function listModels(sdk, { type, cachedOnly, fullRegistry } = {}, c
     });
     return cachedOnly ? rows.filter((row) => row.isCached) : rows;
 }
+export async function customModelRows({ type, cachedOnly }, { modelsDir, loaded }) {
+    const entries = customModels().filter((entry) => !type || (entry.taskType ?? 'llm') === type);
+    const rows = await Promise.all(entries.map(async (entry) => {
+        const addon = entry.taskType ?? 'llm';
+        return {
+            name: entry.name,
+            type: addon,
+            registryPath: entry.src,
+            registrySource: 'custom',
+            isCached: await isCustomModelCached(entry, modelsDir),
+            isLoaded: loaded.has(entry.name),
+            supportsImages: addon === 'llm' && Boolean(entry.projectionSrc),
+            expectedSize: entry.expectedSize ?? 0,
+            label: entry.label
+        };
+    }));
+    return cachedOnly ? rows.filter((row) => row.isCached) : rows;
+}
+export function mergeCustomRows(catalog, custom) {
+    const shadowed = new Set(custom.map((row) => row.name));
+    return [...catalog.filter((row) => !shadowed.has(row.name)), ...custom];
+}