@qvac/harness 0.4.0 → 0.6.0

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,6 +95,8 @@ export interface CuratedListable {
 }
 export declare function curatedListables(): CuratedListable[];
 export declare function curatedModelAsset(name: string, addon: ModelRegistryEntry['addon']): SdkModelAsset | undefined;
+export declare function modelAddonOf(model: string): ModelRegistryEntry['addon'];
+export declare function residentSrc(model: string, addon: ModelRegistryEntry['addon']): string;
 export declare const CUSTOM_TASK_TYPES: readonly ['llm'];
 export type CustomTaskType = (typeof CUSTOM_TASK_TYPES)[number];
 export interface CustomModelEntry {
@@ -113,9 +105,12 @@ export interface CustomModelEntry {
     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 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>;

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,13 +325,20 @@ 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 function modelAddonOf(model) {
+    const known = [...curatedListables(), ...musicListables()].find((entry) => entry.name === model || entry.asset.name === model || entry.asset.src === model);
+    return known?.asset.addon ?? 'llm';
+}
+export function residentSrc(model, addon) {
+    return curatedModelAsset(model, addon)?.src ?? model;
+}
 export const CUSTOM_TASK_TYPES = ['llm'];
 let CUSTOM_MODELS = new Map();
 export function setCustomModels(entries) {
@@ -319,34 +347,40 @@ export function setCustomModels(entries) {
 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, [
@@ -360,8 +394,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.js

@@ -1,30 +1,38 @@
 import fs from 'fs';
-import { downloadedCustomFiles } from './custom-model-cache.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, { modelsDir } = {}) {
     const custom = customModels().find((entry) => entry.name === name);
-    const paths = custom ? downloadedCustomFiles(custom, modelsDir) : await catalogFiles(sdk, name);
+    const { files, dirs } = custom
+        ? await customDownloads(custom, modelsDir)
+        : { files: await catalogFiles(sdk, name), dirs: [] };
     const removed = [];
-    for (const filePath of new Set(paths)) {
+    for (const filePath of new Set(files)) {
         const bytes = await onDiskSize(filePath);
-        if (bytes === null)
+        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)
+        }
+        for (const file of info.cacheFiles) {
             paths.push(file.path);
+        }
     }
     return paths;
 }
@@ -41,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,14 +32,18 @@ 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>;

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

@@ -15,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]);
         }
     };
@@ -46,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)
@@ -64,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) {
@@ -99,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) ?? [];
@@ -134,7 +138,8 @@ export async function customModelRows({ type, cachedOnly }, { modelsDir, loaded
             isCached: await isCustomModelCached(entry, modelsDir),
             isLoaded: loaded.has(entry.name),
             supportsImages: addon === 'llm' && Boolean(entry.projectionSrc),
-            expectedSize: entry.expectedSize ?? 0
+            expectedSize: entry.expectedSize ?? 0,
+            label: entry.label
         };
     }));
     return cachedOnly ? rows.filter((row) => row.isCached) : rows;

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

@@ -66,7 +66,16 @@ export interface LoadedModel {
     model: string;
     refs: number;
 }
-type PoolLike = ReturnType<typeof createModelPool>;
+interface PuddleEntry {
+    readonly id: string;
+    readonly refs: number;
+    readonly value: ModelHandle;
+}
+declare class ModelPuddle extends ResourcePuddle<string, ModelHandle> {
+    readonly resources: Map<string, PuddleEntry>;
+}
+type PoolLike = ModelPuddle;
+export declare function modelOf(key: string): string;
 export declare function releaseModel(pool: PoolLike, key: string): void;
 export declare function loadedModels(pool: PoolLike): LoadedModel[];
 export interface ResidentLease {
@@ -78,10 +87,21 @@ export declare function leaseResidentModel(pool: PoolLike, wanted?: (model: stri
 export declare function isResident(pool: PoolLike, key: string): boolean;
 export declare function leaseCount(pool: PoolLike, key: string): number;
 export declare function evictIdle(pool: PoolLike): Promise<void>;
-export declare function awaitModelCapacity(pool: PoolLike, cap: number, deadlineMs: number, tickMs?: number, signal?: {
-    aborted?: boolean;
-}): Promise<boolean>;
-export declare function evictModelWithin(pool: PoolLike, key: string, deadlineMs: number, tickMs?: number): Promise<boolean>;
+export declare function evictIdleWhere(pool: PoolLike, wanted: (key: string) => boolean): Promise<void>;
+export interface DeadlineOptions {
+    deadlineMs: number;
+    tickMs?: number;
+}
+export interface ModelCapacityOptions extends DeadlineOptions {
+    cap: number;
+    signal?: {
+        aborted?: boolean;
+    } | undefined;
+    evictable?: (key: string) => boolean;
+}
+export declare function awaitModelCapacity(pool: PoolLike, { cap, deadlineMs, tickMs, signal, evictable }: ModelCapacityOptions): Promise<boolean>;
+export declare function evictModelWithin(pool: PoolLike, key: string, options: DeadlineOptions): Promise<boolean>;
+export declare function evictModel(pool: PoolLike, model: string, options: DeadlineOptions): Promise<boolean>;
 export type LoadSdk = () => Promise<ModelLifecycleSdk>;
 export type EmbedLifecycleSdk = Pick<SdkModule, 'unloadModel' | 'modelRegistrySearch'> & Partial<CancelSdk> & {
     loadModel(params: {
@@ -104,11 +124,22 @@ interface LoadClockGuardOptions {
     sampleMs?: number;
     jumpMs?: number;
 }
-export declare function loadClockGuard(model: string, sdk: Partial<CancelSdk>, { now, monoMs, sampleMs, jumpMs }?: LoadClockGuardOptions): {
+interface LoadClockGuard {
     race: (pending: TrackedLoad) => Promise<string>;
-};
-export declare function createModelPool(loadSdk: LoadSdk, notify: NotifyFn, deviceConfig?: LlmDeviceConfig, loads?: LoadTracker): ResourcePuddle<string, ModelHandle>;
-export declare function createEmbedPool(loadSdk: LoadEmbedSdk, notify: NotifyFn, faults: GpuFaultState, batchSize?: number, openclCacheDir?: () => string | undefined, loads?: LoadTracker): ResourcePuddle<string, ModelHandle>;
+}
+export declare function loadClockGuard(model: string, sdk: Partial<CancelSdk>, { now, monoMs, sampleMs, jumpMs }?: LoadClockGuardOptions): LoadClockGuard;
+export interface ModelPoolOptions {
+    deviceConfig?: LlmDeviceConfig;
+    loads?: LoadTracker;
+}
+export declare function createModelPool(loadSdk: LoadSdk, notify: NotifyFn, { deviceConfig, loads }?: ModelPoolOptions): ModelPuddle;
+export interface EmbedPoolOptions {
+    faults: GpuFaultState;
+    batchSize?: number;
+    openclCacheDir?: (() => string | undefined) | undefined;
+    loads?: LoadTracker;
+}
+export declare function createEmbedPool(loadSdk: LoadEmbedSdk, notify: NotifyFn, { faults, batchSize, openclCacheDir, loads }: EmbedPoolOptions): ModelPuddle;
 export type VoiceLifecycleSdk = Pick<SdkModule, 'unloadModel' | 'modelRegistrySearch'> & Partial<CancelSdk> & {
     loadModel(params: {
         modelSrc: ModelSrc;
@@ -118,5 +149,12 @@ export type VoiceLifecycleSdk = Pick<SdkModule, 'unloadModel' | 'modelRegistrySe
     }): TrackedLoad;
 };
 export type LoadVoiceSdk = () => Promise<VoiceLifecycleSdk>;
-export declare function createVoicePool(loadSdk: LoadVoiceSdk, notify: NotifyFn, modelType: string, addon: ModelAddon, modelConfig?: Record<string, unknown>, openclCacheDir?: () => string | undefined, loads?: LoadTracker): ResourcePuddle<string, ModelHandle>;
+export interface VoicePoolOptions {
+    modelType: string;
+    addon: ModelAddon;
+    modelConfig?: Record<string, unknown> | undefined;
+    openclCacheDir?: (() => string | undefined) | undefined;
+    loads?: LoadTracker;
+}
+export declare function createVoicePool(loadSdk: LoadVoiceSdk, notify: NotifyFn, { modelType, addon, modelConfig, openclCacheDir, loads }: VoicePoolOptions): ModelPuddle;
 export {};