@qvac/harness 0.1.0 → 0.1.1

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

@@ -0,0 +1,103 @@
+export const CAPABILITY_PROFILE_ORDER = [
+    'tiny',
+    'low',
+    'mid',
+    'high',
+    'xhigh'
+];
+export const QWEN_35_2B = 'Qwen3.5-2B-Q4_K_M';
+export const QWEN_35_4B = 'Qwen3.5-4B-Q4_K_M';
+export const QWEN_35_9B = 'Qwen3.5-9B-Q4_K_M';
+export const QWEN_36_27B = 'Qwen3.6-27B-UD-Q4_K_XL';
+export const QWEN_36_35B_A3B = 'Qwen3.6-35B-A3B-UD-Q4_K_M';
+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);
+}
+export function meetsMinCapabilityProfile(active, required) {
+    return CAPABILITY_PROFILE_ORDER.indexOf(active) >= CAPABILITY_PROFILE_ORDER.indexOf(required);
+}
+const MODEL_NAME_TO_PROFILE = new Map([
+    [QWEN_35_2B, 'low'],
+    [QWEN_35_4B, 'mid'],
+    [QWEN_35_9B, 'high'],
+    [QWEN_36_27B, 'xhigh'],
+    [QWEN_36_35B_A3B, 'xhigh'],
+    [QWEN_38_27B, 'xhigh'],
+    [MEDPSY_1_7B, 'low'],
+    [MEDPSY_4B, 'mid']
+]);
+export function modelNameToCapabilityProfile(modelName) {
+    return MODEL_NAME_TO_PROFILE.get(modelName);
+}
+const PROFILE_TO_MODEL_NAME = new Map([
+    ['tiny', QWEN_35_2B],
+    ['low', QWEN_35_2B],
+    ['mid', QWEN_35_4B],
+    ['high', QWEN_35_9B],
+    ['xhigh', QWEN_38_27B]
+]);
+export function capabilityProfileToModelName(profile) {
+    const name = PROFILE_TO_MODEL_NAME.get(profile);
+    if (!name)
+        throw new Error(`no model for capability profile ${profile}`);
+    return name;
+}
+export const AGENT_MODEL_NAMES = [
+    QWEN_35_2B,
+    QWEN_35_4B,
+    QWEN_35_9B,
+    QWEN_36_27B,
+    QWEN_36_35B_A3B,
+    QWEN_38_27B,
+    MEDPSY_1_7B,
+    MEDPSY_4B
+];
+export function modelDisplayName(modelName) {
+    const quant = /-(?:UD-)?I?Q\d/i.exec(modelName);
+    const base = quant ? modelName.slice(0, quant.index) : modelName;
+    return base.replace(/-/g, ' ');
+}
+export function capabilityProfileModelLabel(profile) {
+    return modelDisplayName(capabilityProfileToModelName(profile));
+}
+const MULTIMODAL_LLMS = new Set([
+    QWEN_35_2B,
+    QWEN_35_4B,
+    QWEN_35_9B,
+    QWEN_36_27B,
+    QWEN_36_35B_A3B,
+    QWEN_38_27B
+]);
+export function isMultimodalLlm(modelName) {
+    return MULTIMODAL_LLMS.has(modelName);
+}
+export const DEFAULT_IMAGE_MODEL_CHOICE = 'sd2';
+export const IMAGE_CHOICE_CATALOG = [
+    {
+        choice: 'sd2',
+        label: 'Stable Diffusion 2.1 (1B Q8)',
+        requiresGpu: false,
+        supportsMultiImageEdit: false,
+        sizeBytesApprox: 2_300_000_000,
+        notes: 'Fast, 512x512 sweet spot, SDEdit img2img.'
+    },
+    {
+        choice: 'sdxl',
+        label: 'SDXL Base 1.0 (3B Q4)',
+        requiresGpu: true,
+        supportsMultiImageEdit: false,
+        sizeBytesApprox: 3_900_000_000,
+        notes: 'Higher quality, 1024x1024 native.'
+    },
+    {
+        choice: 'flux2-klein',
+        label: 'FLUX.2 Klein (4B Q4 + Qwen3 + VAE)',
+        requiresGpu: true,
+        supportsMultiImageEdit: true,
+        sizeBytesApprox: 5_100_000_000,
+        notes: 'In-context img2img + multi-ref fusion. Set prediction=flux2_flow for editing.'
+    }
+];

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

@@ -0,0 +1,125 @@
+import type { ModelRegistryEntry, ToolDialect } from '@qvac/sdk';
+import type { ModelAddon } from './model-source.ts';
+export interface SdkModelAsset extends ModelRegistryEntry {
+    readonly src: string;
+}
+import { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, type CapabilityProfile, type ImageModelChoice, type ImageChoiceEntry } from './model-catalog-constants.ts';
+export { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG };
+export type { CapabilityProfile, ImageModelChoice, ImageChoiceEntry };
+export interface LlmCatalogEntry {
+    readonly name: string;
+    readonly weight: SdkModelAsset;
+    readonly capabilityProfile: CapabilityProfile;
+    readonly projection?: SdkModelAsset;
+    readonly textOnly?: true;
+}
+export declare const LLM_CATALOG: ReadonlyArray<LlmCatalogEntry>;
+export declare function defaultProjectionMap(): Record<string, string>;
+export type ModelCategory = 'tts' | 'transcription' | 'embedding';
+export interface CategoryDefault {
+    readonly name: string;
+    readonly category: ModelCategory;
+    readonly asset: SdkModelAsset;
+}
+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 declare function mediaModelNameFor(category: ModelCategory, profile: CapabilityProfile): string;
+export interface DiffusionCatalogEntry {
+    readonly choice: ImageModelChoice;
+    readonly name: string;
+    readonly model: SdkModelAsset;
+    readonly llmModel?: SdkModelAsset;
+    readonly vaeModel?: SdkModelAsset;
+    readonly prediction?: 'flux2_flow';
+    readonly requiresGpu: boolean;
+    readonly supportsImg2Img: boolean;
+}
+export declare const DIFFUSION_CATALOG: ReadonlyArray<DiffusionCatalogEntry>;
+export interface DiffusionDownloadMetadata {
+    readonly companions: ReadonlyArray<string>;
+    readonly assetSizes: Readonly<Record<string, number>>;
+}
+export declare function diffusionDownloadName(model: string): string | null;
+export declare function diffusionDownloadMetadata(model: string, addon: ModelAddon | undefined): DiffusionDownloadMetadata | undefined;
+import { DEFAULT_MUSIC_MODEL_CHOICE, type MusicModelChoice } from './music-catalog.ts';
+export { DEFAULT_MUSIC_MODEL_CHOICE, type MusicModelChoice };
+export interface AudioGenCatalogEntry {
+    readonly choice: MusicModelChoice;
+    readonly name: string;
+    readonly dit: SdkModelAsset;
+    readonly textEnc: SdkModelAsset;
+    readonly lm: SdkModelAsset;
+    readonly vae: SdkModelAsset;
+    readonly requiresGpu: boolean;
+    readonly defaultSteps: number;
+}
+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 interface AudioGenDownloadMetadata {
+    readonly companions: ReadonlyArray<string>;
+    readonly assetSizes: Readonly<Record<string, number>>;
+}
+export declare function audioGenDownloadMetadata(model: string, addon: ModelAddon | undefined): AudioGenDownloadMetadata | undefined;
+export interface AgentSkillModelInput {
+    readonly enabledSkills?: ReadonlyArray<string> | null;
+    readonly installedSkills?: ReadonlyArray<string> | null;
+    readonly skillsScope?: 'all' | 'selected' | null;
+    readonly imageModelChoice?: ImageModelChoice | null;
+    readonly musicModelChoice?: MusicModelChoice | null;
+}
+export declare function skillModelsForAgent(agent: AgentSkillModelInput): ReadonlyArray<{
+    readonly name: string;
+    readonly addon: ModelAddon;
+}>;
+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 interface ImageClamps {
+    maxDim?: number;
+    maxSteps?: number;
+}
+export declare function imageClampsFromEnv(env: Record<string, string | undefined>): ImageClamps | undefined;
+export declare function imageModelFromEnv(env: Record<string, string | undefined>, onIgnoredCompanions?: () => void, onIgnoredPrediction?: () => void): NonNullable<ReturnType<typeof imageModelFor>> | undefined;
+export interface CuratedListable {
+    readonly name: string;
+    readonly asset: SdkModelAsset;
+    readonly companions: SdkModelAsset[];
+    readonly projection?: SdkModelAsset;
+}
+export declare function curatedListables(): CuratedListable[];
+export declare function curatedModelAsset(name: string, addon: ModelRegistryEntry['addon']): SdkModelAsset | undefined;
+export interface CustomModelEntry {
+    readonly name: string;
+    readonly src: string;
+    readonly projectionSrc?: string;
+}
+export declare function setCustomModels(entries: ReadonlyArray<CustomModelEntry>): void;
+export declare function customModelSrc(name: string): string | undefined;
+export declare function customToolDialect(name: string): ToolDialect | undefined;
+export declare function customProjectionMap(): Record<string, string>;
+export declare function companionRegistryPaths(): Map<string, string[]>;
+export declare function audioGenModelByName(name: string): SdkModelAsset | undefined;
+export interface MusicListable {
+    readonly name: string;
+    readonly asset: SdkModelAsset;
+    readonly companions: ReadonlyArray<SdkModelAsset>;
+    readonly expectedSize: number;
+}
+export declare function musicListables(): MusicListable[];

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

@@ -0,0 +1,371 @@
+import { AUDIOGEN_ACESTEP_5HZ_LM_0_6B_Q8_0, AUDIOGEN_ACESTEP_V15_SFT_Q8_0, AUDIOGEN_ACESTEP_V15_TURBO_Q4_K_M, AUDIOGEN_ACESTEP_V15_TURBO_Q8_0, AUDIOGEN_QWEN3_EMBEDDING_0_6B_Q8_0, AUDIOGEN_VAE_BF16, EMBEDDINGGEMMA_300M_Q4_0, FLUX_2_KLEIN_4B_Q4_0, FLUX_2_KLEIN_4B_VAE, HEALTHCARE_1_7B_MEDICAL_Q4_K_M, HEALTHCARE_4B_MEDICAL_Q4_K_M, MMPROJ_QWEN3_5_2B_MULTIMODAL_Q8_0, MMPROJ_QWEN3_5_4B_MULTIMODAL_Q8_0, MMPROJ_QWEN3_5_9B_MULTIMODAL_F16, MMPROJ_QWEN3_6_27B_MULTIMODAL_F16, MMPROJ_QWEN3_6_35B_A3B_MULTIMODAL_F16, MMPROJ_QWEN3_8_27B_MULTIMODAL_F16, QWEN3_5_2B_MULTIMODAL_Q4_K_M, QWEN3_5_4B_MULTIMODAL_Q4_K_M, QWEN3_5_9B_MULTIMODAL_Q4_K_M, PARAKEET_TDT_0_6B_V3_Q8_0, QWEN3_4B_Q4_K_M, QWEN3_6_27B_MULTIMODAL_Q4_K_XL, QWEN3_6_35B_A3B_MULTIMODAL_Q4_K_M, QWEN3_8_27B_MULTIMODAL_UD_Q4_K_XL, SD_V2_1_1B_Q8_0, SDXL_BASE_1_0_3B_Q4_0, TTS_MULTILINGUAL_SUPERTONIC3_Q4_0, TTS_MULTILINGUAL_SUPERTONIC3_Q8_0 } from '@qvac/sdk/models';
+import { detectToolDialect } from "./tool-dialect.js";
+import { defaultTtsModelName } from "./tts-model-default.js";
+import { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG } from "./model-catalog-constants.js";
+export { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG };
+export const LLM_CATALOG = [
+    {
+        name: QWEN_35_2B,
+        weight: QWEN3_5_2B_MULTIMODAL_Q4_K_M,
+        capabilityProfile: 'low',
+        projection: MMPROJ_QWEN3_5_2B_MULTIMODAL_Q8_0
+    },
+    {
+        name: QWEN_35_4B,
+        weight: QWEN3_5_4B_MULTIMODAL_Q4_K_M,
+        capabilityProfile: 'mid',
+        projection: MMPROJ_QWEN3_5_4B_MULTIMODAL_Q8_0
+    },
+    {
+        name: QWEN_35_9B,
+        weight: QWEN3_5_9B_MULTIMODAL_Q4_K_M,
+        capabilityProfile: 'high',
+        projection: MMPROJ_QWEN3_5_9B_MULTIMODAL_F16
+    },
+    {
+        name: QWEN_36_27B,
+        weight: QWEN3_6_27B_MULTIMODAL_Q4_K_XL,
+        capabilityProfile: 'xhigh',
+        projection: MMPROJ_QWEN3_6_27B_MULTIMODAL_F16
+    },
+    {
+        name: QWEN_36_35B_A3B,
+        weight: QWEN3_6_35B_A3B_MULTIMODAL_Q4_K_M,
+        capabilityProfile: 'xhigh',
+        projection: MMPROJ_QWEN3_6_35B_A3B_MULTIMODAL_F16
+    },
+    {
+        name: MEDPSY_1_7B,
+        weight: HEALTHCARE_1_7B_MEDICAL_Q4_K_M,
+        capabilityProfile: 'low',
+        textOnly: true
+    },
+    {
+        name: MEDPSY_4B,
+        weight: HEALTHCARE_4B_MEDICAL_Q4_K_M,
+        capabilityProfile: 'mid',
+        textOnly: true
+    },
+    {
+        name: QWEN_38_27B,
+        weight: QWEN3_8_27B_MULTIMODAL_UD_Q4_K_XL,
+        capabilityProfile: 'xhigh',
+        projection: MMPROJ_QWEN3_8_27B_MULTIMODAL_F16
+    }
+];
+export function defaultProjectionMap() {
+    const map = {};
+    for (const entry of LLM_CATALOG) {
+        if (entry.projection)
+            map[entry.name] = entry.projection.src;
+    }
+    return map;
+}
+export const CATEGORY_DEFAULTS = [
+    { name: 'Supertonic3-Q4_0', category: 'tts', asset: TTS_MULTILINGUAL_SUPERTONIC3_Q4_0 },
+    { name: 'Supertonic3-Q8_0', category: 'tts', asset: TTS_MULTILINGUAL_SUPERTONIC3_Q8_0 },
+    {
+        name: 'Parakeet-TDT-0.6B-v3-Q8_0',
+        category: 'transcription',
+        asset: PARAKEET_TDT_0_6B_V3_Q8_0
+    },
+    { name: 'EmbeddingGemma-300M-Q4_0', category: 'embedding', asset: EMBEDDINGGEMMA_300M_Q4_0 }
+];
+export function defaultVoiceModel(category) {
+    const entry = CATEGORY_DEFAULTS.find((candidate) => candidate.category === category);
+    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);
+}
+export function infraModelsFor(profile) {
+    const tts = defaultTtsFor(profile);
+    const rest = CATEGORY_DEFAULTS.filter((entry) => entry.category !== 'tts');
+    return [tts, ...rest].map((entry) => ({ name: entry.name, addon: entry.asset.addon }));
+}
+export function mediaModelNameFor(category, profile) {
+    if (category === 'tts')
+        return defaultTtsFor(profile).name;
+    const entry = CATEGORY_DEFAULTS.find((candidate) => candidate.category === category);
+    if (!entry)
+        throw new Error(`no default model for category ${category}`);
+    return entry.name;
+}
+const IMAGE_GENERATION_SKILL = 'image-generation';
+export const DIFFUSION_CATALOG = [
+    {
+        choice: 'sd2',
+        name: 'StableDiffusion-2.1-Q8_0',
+        model: SD_V2_1_1B_Q8_0,
+        requiresGpu: false,
+        supportsImg2Img: true
+    },
+    {
+        choice: 'sdxl',
+        name: 'SDXL-Base-1.0-Q4_0',
+        model: SDXL_BASE_1_0_3B_Q4_0,
+        requiresGpu: true,
+        supportsImg2Img: true
+    },
+    {
+        choice: 'flux2-klein',
+        name: 'FLUX.2-Klein-4B-Q4_0',
+        model: FLUX_2_KLEIN_4B_Q4_0,
+        llmModel: QWEN3_4B_Q4_K_M,
+        vaeModel: FLUX_2_KLEIN_4B_VAE,
+        prediction: 'flux2_flow',
+        requiresGpu: true,
+        supportsImg2Img: true
+    }
+];
+function diffusionAssets(entry) {
+    const assets = [entry.model];
+    if (entry.llmModel)
+        assets.push(entry.llmModel);
+    if (entry.vaeModel)
+        assets.push(entry.vaeModel);
+    return assets;
+}
+function diffusionCatalogEntry(model) {
+    return DIFFUSION_CATALOG.find((candidate) => candidate.choice === model ||
+        candidate.name === model ||
+        candidate.model.name === model ||
+        candidate.model.src === model);
+}
+export function diffusionDownloadName(model) {
+    return diffusionCatalogEntry(model)?.name ?? null;
+}
+export function diffusionDownloadMetadata(model, addon) {
+    if (addon !== 'diffusion')
+        return undefined;
+    const entry = diffusionCatalogEntry(model);
+    if (!entry)
+        return undefined;
+    const assets = diffusionAssets(entry);
+    const assetSizes = {};
+    for (const asset of assets)
+        assetSizes[asset.src] = asset.expectedSize;
+    return {
+        companions: assets.slice(1).map((asset) => asset.src),
+        assetSizes
+    };
+}
+import { DEFAULT_MUSIC_MODEL_CHOICE } from "./music-catalog.js";
+export { DEFAULT_MUSIC_MODEL_CHOICE };
+const MUSIC_GENERATION_SKILL = 'music-generation';
+export const AUDIOGEN_CATALOG = [
+    {
+        choice: 'turbo',
+        name: 'ACE-Step-1.5-Turbo-Q4_K_M',
+        dit: AUDIOGEN_ACESTEP_V15_TURBO_Q4_K_M,
+        textEnc: AUDIOGEN_QWEN3_EMBEDDING_0_6B_Q8_0,
+        lm: AUDIOGEN_ACESTEP_5HZ_LM_0_6B_Q8_0,
+        vae: AUDIOGEN_VAE_BF16,
+        requiresGpu: false,
+        defaultSteps: 8
+    },
+    {
+        choice: 'turbo-hq',
+        name: 'ACE-Step-1.5-Turbo-Q8_0',
+        dit: AUDIOGEN_ACESTEP_V15_TURBO_Q8_0,
+        textEnc: AUDIOGEN_QWEN3_EMBEDDING_0_6B_Q8_0,
+        lm: AUDIOGEN_ACESTEP_5HZ_LM_0_6B_Q8_0,
+        vae: AUDIOGEN_VAE_BF16,
+        requiresGpu: true,
+        defaultSteps: 8
+    },
+    {
+        choice: 'sft',
+        name: 'ACE-Step-1.5-SFT-Q8_0',
+        dit: AUDIOGEN_ACESTEP_V15_SFT_Q8_0,
+        textEnc: AUDIOGEN_QWEN3_EMBEDDING_0_6B_Q8_0,
+        lm: AUDIOGEN_ACESTEP_5HZ_LM_0_6B_Q8_0,
+        vae: AUDIOGEN_VAE_BF16,
+        requiresGpu: true,
+        defaultSteps: 24
+    }
+];
+export function musicDefaultSteps(choice) {
+    return AUDIOGEN_CATALOG.find((entry) => entry.choice === choice)?.defaultSteps;
+}
+export function musicChoiceForDit(dit) {
+    return AUDIOGEN_CATALOG.find((entry) => entry.dit.src === dit || entry.dit.name === dit)?.choice;
+}
+function audioGenStages(entry) {
+    return [entry.dit, entry.textEnc, entry.lm, entry.vae];
+}
+export function musicSizeBytes(entry) {
+    return audioGenStages(entry).reduce((sum, asset) => sum + asset.expectedSize, 0);
+}
+export function musicModelSet(choice) {
+    const entry = AUDIOGEN_CATALOG.find((candidate) => candidate.choice === choice);
+    if (!entry)
+        return null;
+    return {
+        dit: entry.dit.src,
+        textEnc: entry.textEnc.src,
+        lm: entry.lm.src,
+        vae: entry.vae.src
+    };
+}
+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)
+        return undefined;
+    const stages = audioGenStages(entry);
+    const assetSizes = {};
+    for (const asset of stages)
+        assetSizes[asset.src] = asset.expectedSize;
+    return {
+        companions: stages.slice(1).map((asset) => asset.src),
+        assetSizes
+    };
+}
+function agentHasSkill(agent, skill) {
+    const installed = agent.installedSkills?.includes(skill) === true;
+    return installed && (agent.skillsScope === 'all' || agent.enabledSkills?.includes(skill) === true);
+}
+export function skillModelsForAgent(agent) {
+    const models = [];
+    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)
+            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)
+            models.push({ name: entry.name, addon: entry.dit.addon });
+    }
+    return models;
+}
+export function diffusionSizeBytes(entry) {
+    return diffusionAssets(entry).reduce((sum, asset) => sum + asset.expectedSize, 0);
+}
+export function imageModelFor(choice) {
+    const entry = DIFFUSION_CATALOG.find((candidate) => candidate.choice === choice);
+    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 } : {})
+    };
+}
+export function imageClampsFromEnv(env) {
+    const positive = (value) => {
+        const n = Math.floor(Number(value));
+        return Number.isFinite(n) && n > 0 ? n : undefined;
+    };
+    const maxDim = positive(env.QVAC_IMAGE_MAX_DIM);
+    const maxSteps = positive(env.QVAC_IMAGE_MAX_STEPS);
+    if (!maxDim && !maxSteps)
+        return undefined;
+    return { ...(maxDim ? { maxDim } : {}), ...(maxSteps ? { maxSteps } : {}) };
+}
+export function imageModelFromEnv(env, onIgnoredCompanions, onIgnoredPrediction) {
+    const catalog = imageModelFor(env.QVAC_IMAGE_MODEL);
+    if (catalog) {
+        if (env.QVAC_IMAGE_LLM || env.QVAC_IMAGE_VAE || env.QVAC_IMAGE_PREDICTION) {
+            onIgnoredCompanions?.();
+        }
+        return catalog;
+    }
+    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)
+        onIgnoredPrediction?.();
+    return {
+        model: env.QVAC_IMAGE_MODEL,
+        llmModel: env.QVAC_IMAGE_LLM || undefined,
+        vaeModel: env.QVAC_IMAGE_VAE || undefined,
+        prediction: fluxSet ? prediction : undefined
+    };
+}
+export function curatedListables() {
+    return [
+        ...LLM_CATALOG.map((entry) => ({
+            name: entry.name,
+            asset: entry.weight,
+            companions: [],
+            projection: entry.projection
+        })),
+        ...CATEGORY_DEFAULTS.map((entry) => ({ name: entry.name, asset: entry.asset, companions: [] })),
+        ...DIFFUSION_CATALOG.map((entry) => ({
+            name: entry.name,
+            asset: entry.model,
+            companions: [entry.llmModel, entry.vaeModel].filter(Boolean)
+        }))
+    ];
+}
+export function curatedModelAsset(name, addon) {
+    return curatedListables().find((entry) => entry.asset.addon === addon && (entry.name === name || entry.asset.name === name))?.asset;
+}
+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 customToolDialect(name) {
+    const entry = CUSTOM_MODELS.get(name);
+    return entry ? detectToolDialect(entry.src, entry.name) : undefined;
+}
+export function customProjectionMap() {
+    const map = {};
+    for (const entry of CUSTOM_MODELS.values()) {
+        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)
+            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)
+            map.set(entry.model.registryPath, companions);
+    }
+    for (const entry of AUDIOGEN_CATALOG) {
+        map.set(entry.dit.registryPath, [
+            entry.textEnc.registryPath,
+            entry.lm.registryPath,
+            entry.vae.registryPath
+        ]);
+    }
+    return map;
+}
+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)
+                return name === entry.name ? entry.dit : stage;
+        }
+    }
+    return undefined;
+}
+export function musicListables() {
+    return AUDIOGEN_CATALOG.map((entry) => ({
+        name: entry.name,
+        asset: entry.dit,
+        companions: [entry.textEnc, entry.lm, entry.vae],
+        expectedSize: musicSizeBytes(entry)
+    }));
+}

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

@@ -0,0 +1,18 @@
+import type * as QvacSdk from '@qvac/sdk';
+export type ModelDeleteSdk = Pick<typeof QvacSdk, 'getModelInfo'>;
+export interface DeletedModelFile {
+    readonly path: string;
+    readonly bytes: number;
+}
+export interface DeleteModelResult {
+    readonly name: string;
+    readonly removed: ReadonlyArray<DeletedModelFile>;
+    readonly freedBytes: number;
+}
+export interface DeleteModelSummary {
+    readonly name: string;
+    readonly removed: number;
+    readonly freedBytes: number;
+}
+export declare function summarizeDelete(result: DeleteModelResult): DeleteModelSummary;
+export declare function deleteModelFiles(sdk: ModelDeleteSdk, name: string): Promise<DeleteModelResult>;

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

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import { curatedListables, 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();
+    const removed = [];
+    for (const catalogName of namesToPurge(name)) {
+        const info = await sdk.getModelInfo({ name: catalogName }).catch(() => null);
+        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 });
+        }
+    }
+    return { name, removed, freedBytes: removed.reduce((sum, file) => sum + file.bytes, 0) };
+}
+async function onDiskSize(filePath) {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        return stat.isFile() ? stat.size : null;
+    }
+    catch {
+        return null;
+    }
+}
+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)
+            names.push(curated.projection.name);
+        return names;
+    }
+    const music = musicListables().find((entry) => entry.name === name || entry.asset.name === name);
+    if (music)
+        return [music.asset.name, ...music.companions.map((stage) => stage.name)];
+    return [name];
+}

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

@@ -0,0 +1,18 @@
+export interface ModelResource {
+    model: string;
+    modelId: string;
+    ctxSize?: number;
+}
+export interface ModelHandleOptions {
+    load(): Promise<ModelResource>;
+}
+export declare class ModelHandle {
+    private readonly _load;
+    private readonly _peek;
+    private _tracked;
+    private _loading;
+    constructor({ load }: ModelHandleOptions);
+    load(): Promise<ModelResource>;
+    get loading(): boolean;
+    peek(): Promise<ModelResource> | null;
+}