@qvac/harness 0.5.0 → 0.7.0

package/dist-lib/index.js

@@ -4,7 +4,7 @@ import process from 'process';
 import ReadyResource from 'ready-resource';
 import { probeGpuStats } from './lib/hardware/gpu-probe.js';
 import { probeCapabilityProfile } from './lib/hardware/capability-probe.js';
-import { closePythonWorker } from './lib/tools/exec/adapters/python/worker/client.js';
+import { closePythonWorker } from './lib/tools/exec/adapters/python/worker/active.js';
 import { completion, imageSettingsFrom } from './lib/capabilities/completion.js';
 import { detectLanguage } from './lib/capabilities/detect-language.js';
 import { invoke } from './lib/capabilities/invoke.js';
@@ -21,10 +21,11 @@ import { buildWavBuffer } from './lib/wav-encode.js';
 import { createVoiceLane, packSamples, speakOnce, speakStreamOnce, transcribeOnce, transcribeStreaming, SUPERTONIC_SAMPLE_RATE } from './lib/capabilities/voice.js';
 import { pushQueue } from './lib/queue.js';
 import { AbortedError, raceAbort } from './lib/helpers/race-abort.js';
-import { audioGenDownloadMetadata, customProjectionMap, defaultProjectionMap, defaultTtsFor, defaultVoiceModel, diffusionDownloadMetadata, infraModelsFor, modelNameToCapabilityProfile, musicModelSet, setCustomModels } from './lib/models/model-catalog.js';
+import { audioGenDownloadMetadata, customProjectionMap, defaultProjectionMap, defaultTtsFor, defaultVoiceModel, diffusionDownloadMetadata, curatedModelAsset, infraModelsFor, modelAddonOf, modelNameToCapabilityProfile, musicModelSet, residentSrc, setCustomModels } from './lib/models/model-catalog.js';
 import { createModelStatusCache, customModelRows, invalidateModelStatusCache, mergeCustomRows, listModels } from './lib/models/model-list.js';
 import { deleteModelFiles, summarizeDelete } from './lib/models/model-delete.js';
-import { createEmbedPool, createLoadTracker, createModelPool, createVoicePool, awaitModelCapacity, evictIdle, evictModelWithin, isResident, leaseResidentModel, leaseCount, loadedModels, modelKey, releaseModel, resolveLoadOptions, progressState } from './lib/models/model-pool.js';
+import { createEmbedPool, createLoadTracker, createModelPool, createVoicePool, awaitModelCapacity, evictIdle, evictIdleWhere, evictModel, evictModelWithin, isResident, leaseResidentModel, leaseCount, loadedModels, modelKey, modelOf, releaseModel, resolveLoadOptions, progressState } from './lib/models/model-pool.js';
+import { defaultContextSize } from './lib/models/context.js';
 import { resolveMainGpu } from './lib/models/gpu-selection.js';
 import { createIdleReaper } from './lib/models/idle-unload.js';
 import { openclCacheDir } from './lib/models/opencl-cache.js';
@@ -45,7 +46,7 @@ import { hlog } from './lib/log.js';
 import { harness } from './spec/index.js';
 import { installResolutionDetector, resolutionDetail } from './lib/resolution-detector.js';
 import { probeBinVersions } from './lib/tools/skills/bin-check.js';
-import { bareRuntime } from './lib/tools/exec.js';
+import { bareRuntime } from './lib/tools/exec/bare-runtime.js';
 import { runCommand } from './lib/tools/exec/runner.js';
 import { createLocalRoots } from './lib/tools/fs/local.js';
 import { createRemoteRoots } from './lib/tools/fs/remote.js';
@@ -81,6 +82,7 @@ const MUSIC_EVICT_WAIT_MS = 15_000;
 const WEDGED_EVICT_WAIT_MS = 10_000;
 const MODEL_ROOM_WAIT_MS = 300_000;
 const WARM_ROOM_WAIT_MS = 2_000;
+const UNLOAD_LEASE_WAIT_MS = 10_000;
 const DEFAULT_COMPLETION_MODEL_CAP = 1;
 const WEDGED_EVICT_LEASED_MS = 120_000;
 const TTS_MODEL_CONFIG = {
@@ -93,6 +95,8 @@ export class Harness extends ReadyResource {
     _tools;
     _sdk;
     _loads = createLoadTracker();
+    _pinned = new Set();
+    _replying = [];
     _modelStatus = createModelStatusCache();
     _models;
     _embedModels;
@@ -520,19 +524,18 @@ export class Harness extends ReadyResource {
         this._idle.configure(ms);
     }
     previewModelSource(context) {
-        return previewModelSource(context, {
-            assessFit: async ({ sha256Checksum, name, contextTokens }) => {
-                const sdk = await this._sdk.load();
-                const result = await sdk.assessModelFit({
-                    models: [{ model: { sha256Checksum, name }, workload: { kind: 'llm', contextTokens } }]
-                });
-                const model = result.models[0];
-                return {
-                    fit: model?.verdict ?? result.verdict,
-                    fitReasons: [...(model?.reasons ?? result.reasons)]
-                };
-            }
+        return previewModelSource(context, { assessFit: (query) => this._assessFit(query) });
+    }
+    async _assessFit({ sha256Checksum, name, contextTokens }) {
+        const sdk = await this._sdk.load();
+        const result = await sdk.assessModelFit({
+            models: [{ model: { sha256Checksum, name }, workload: { kind: 'llm', contextTokens } }]
         });
+        const model = result.models[0];
+        return {
+            fit: model?.verdict ?? result.verdict,
+            fitReasons: [...(model?.reasons ?? result.reasons)]
+        };
     }
     async describe() {
         if (!this.opened)
@@ -595,7 +598,7 @@ export class Harness extends ReadyResource {
         const key = modelKey(model, loadOpts);
         const pool = this._models;
         if (!isResident(pool, key)) {
-            await this._makeRoomForCompletion(signal);
+            await this._makeRoomForCompletion(model, { ctxSize: loadOpts.ctxSize, signal });
         }
         try {
             const { modelId } = await raceAbort(pool.open(key, model, loadOpts).load(), signal);
@@ -630,7 +633,7 @@ export class Harness extends ReadyResource {
     }
     _createPool() {
         const loadSdk = this._sdk.load;
-        return createModelPool(loadSdk, (state) => this._notifyModel(state, { languageModel: true }), {
+        return createModelPool(loadSdk, (state) => this._notifyModel(state), {
             deviceConfig: this._deviceConfig(),
             loads: this._loads
         });
@@ -663,11 +666,18 @@ export class Harness extends ReadyResource {
             loads: this._loads
         });
     }
-    _notifyModel(state, { languageModel = false } = {}) {
-        const catalogChanged = languageModel && (state.status === 'ready' || state.status === 'unloaded');
+    _notifyModel(state) {
+        const catalogChanged = state.status === 'ready' || state.status === 'unloaded';
         if (catalogChanged) {
             invalidateModelStatusCache(this._modelStatus);
         }
+        if (state.status === 'unloaded') {
+            for (const key of this._pinned) {
+                if (!isResident(this._models, key)) {
+                    this._pinned.delete(key);
+                }
+            }
+        }
         this.emit('model', { ...state, catalogChanged, loaded: this._loadedModels() });
     }
     async _collectRetiredEmbedPool(pool) {
@@ -874,7 +884,7 @@ export class Harness extends ReadyResource {
         const pool = this._embedModels;
         const faults = this._embedFaults;
         const generation = faults.generation;
-        const key = faults.key(model);
+        const key = faults.key(residentSrc(model, 'embeddings'));
         const handle = pool.open(key, model);
         let loaded = null;
         let job = null;
@@ -929,7 +939,8 @@ export class Harness extends ReadyResource {
             await this.ready();
         if (this.suspended)
             throw new Error('harness is suspended');
-        const name = model || (await this._defaultVoiceSrc(category));
+        const addon = category === 'tts' ? 'tts' : 'parakeet';
+        const name = residentSrc(model || (await this._defaultVoiceSrc(category)), addon);
         const handle = pool.open(name, name);
         let job = null;
         let releaseAfter = null;
@@ -997,7 +1008,7 @@ export class Harness extends ReadyResource {
             await this.ready();
         if (this.suspended)
             throw new Error('harness is suspended');
-        const name = model || (await this._defaultVoiceSrc('tts'));
+        const name = residentSrc(model || (await this._defaultVoiceSrc('tts')), 'tts');
         const pool = this._ttsModels;
         const handle = pool.open(name, name);
         const chunks = pushQueue();
@@ -1123,29 +1134,143 @@ export class Harness extends ReadyResource {
             await this.ready();
         if (this.suspended)
             return;
-        const projectionModel = this._projectionFor(model);
-        const loadOpts = resolveLoadOptions({
-            ctxSize: agent?.ctxSize ?? undefined,
-            kvCacheK: agent?.kvCacheK ?? undefined,
-            kvCacheV: agent?.kvCacheV ?? undefined,
-            projectionModel
-        }, this._deviceConfig());
-        const key = modelKey(model, loadOpts);
-        const pool = this._models;
-        hlog('warm model', { model, resident: isResident(pool, key) });
-        if (!isResident(pool, key)) {
-            if (!(await this._makeRoomForCompletion(signal, WARM_ROOM_WAIT_MS))) {
+        const target = this._residency(model, agent);
+        const resident = isResident(target.pool, target.key);
+        hlog('warm model', { model, resident });
+        if (target.pool === this._models && !resident) {
+            const roomed = await this._makeRoomForCompletion(model, {
+                ctxSize: target.ctxSize,
+                signal,
+                deadlineMs: WARM_ROOM_WAIT_MS
+            });
+            if (!roomed) {
                 return;
             }
-            await this._imageRuntime?.unloadIdle().catch(noop);
+            await this._unloadIdleGenerators();
+        }
+        await this._loadAndRelease(target, signal);
+    }
+    loadModel(context) {
+        return this._busy(() => this._loadModel(context));
+    }
+    async _loadModel({ model, agent, signal }) {
+        if (!this.opened)
+            await this.ready();
+        if (this.suspended) {
+            throw new Error('harness is suspended');
+        }
+        const target = this._residency(model, agent);
+        const resident = isResident(target.pool, target.key);
+        hlog('load model', { model, resident });
+        if (target.pool !== this._models) {
+            await this._loadAndRelease(target, signal);
+            return { loaded: true };
+        }
+        if (!resident) {
+            if (!(await this._fits(model, target.ctxSize))) {
+                return { loaded: false, reason: 'memory' };
+            }
+            await evictIdleWhere(this._models, (key) => modelOf(key) === model && !this._replying.includes(key));
+            await this._unloadIdleGenerators();
+        }
+        this._pinned.add(target.key);
+        try {
+            await this._loadAndRelease(target, signal);
+        }
+        catch (err) {
+            this._pinned.delete(target.key);
+            throw err;
+        }
+        return { loaded: true };
+    }
+    unloadModel(context) {
+        return this._busy(() => this._unloadModel(context));
+    }
+    async _unloadModel({ model }) {
+        if (!this.opened)
+            await this.ready();
+        const target = this._residency(model);
+        const name = modelOf(target.key);
+        const unloaded = await evictModel(target.pool, name, { deadlineMs: UNLOAD_LEASE_WAIT_MS });
+        hlog('unload model', { model, unloaded });
+        if (unloaded) {
+            for (const key of this._pinned) {
+                if (modelOf(key) === name) {
+                    this._pinned.delete(key);
+                }
+            }
         }
+        return { unloaded };
+    }
+    async _loadAndRelease(target, signal) {
         try {
-            await raceAbort(pool.open(key, model, loadOpts).load(), signal);
+            await raceAbort(target.open().load(), signal);
         }
         finally {
-            releaseModel(pool, key);
+            releaseModel(target.pool, target.key);
         }
     }
+    async _unloadIdleGenerators() {
+        await this._imageRuntime?.unloadIdle().catch(noop);
+        await this._musicRuntime?.unloadIdle().catch(noop);
+    }
+    async _fits(model, ctxSize) {
+        const asset = curatedModelAsset(model, 'llm');
+        if (!asset) {
+            return true;
+        }
+        const assessed = await this._assessFit({
+            sha256Checksum: asset.sha256Checksum,
+            name: asset.name,
+            contextTokens: ctxSize || defaultContextSize(asset)
+        }).catch((err) => {
+            hlog('fit estimate failed', { model, err: errorMessage(err) });
+            return null;
+        });
+        return assessed?.fit !== 'likely-too-large';
+    }
+    async _yieldPins(model, ctxSize) {
+        for (const key of this._pinned) {
+            if (leaseCount(this._models, key) > 0 || this._replying.includes(key)) {
+                continue;
+            }
+            if (await this._fits(model, ctxSize))
+                return;
+            this._pinned.delete(key);
+            await evictModelWithin(this._models, key, { deadlineMs: WEDGED_EVICT_WAIT_MS });
+        }
+    }
+    _residency(model, agent) {
+        const addon = modelAddonOf(model);
+        if (addon === 'llm') {
+            const loadOpts = this._completionLoadOptions(model, agent);
+            const key = modelKey(model, loadOpts);
+            return {
+                pool: this._models,
+                key,
+                ctxSize: loadOpts.ctxSize,
+                open: () => this._models.open(key, model, loadOpts)
+            };
+        }
+        if (addon === 'embeddings') {
+            const key = this._embedFaults.key(residentSrc(model, addon));
+            return { pool: this._embedModels, key, open: () => this._embedModels.open(key, model) };
+        }
+        if (addon === 'tts' || addon === 'parakeet') {
+            const pool = addon === 'tts' ? this._ttsModels : this._transcriptionModels;
+            const key = residentSrc(model, addon);
+            return { pool, key, open: () => pool.open(key, key) };
+        }
+        throw new Error(`${model} loads for each generation and is not kept in memory`);
+    }
+    _completionLoadOptions(model, agent) {
+        return resolveLoadOptions({
+            ctxSize: agent?.ctxSize ?? undefined,
+            kvCacheK: agent?.kvCacheK ?? undefined,
+            kvCacheV: agent?.kvCacheV ?? undefined,
+            projectionModel: this._projectionFor(model)
+        }, this._deviceConfig());
+    }
     invoke(context) {
         return this._busyStream(() => this._invoke(context));
     }
@@ -1184,27 +1309,20 @@ export class Harness extends ReadyResource {
             await this.ready();
         if (this.suspended)
             throw new Error('harness is suspended');
-        const projectionModel = this._projectionFor(model);
-        const loadOpts = resolveLoadOptions({
-            ctxSize: agent?.ctxSize ?? undefined,
-            kvCacheK: agent?.kvCacheK ?? undefined,
-            kvCacheV: agent?.kvCacheV ?? undefined,
-            projectionModel
-        }, this._deviceConfig());
+        const loadOpts = this._completionLoadOptions(model, agent);
+        const projectionModel = loadOpts.projectionModel;
         const key = modelKey(model, loadOpts);
         const pool = this._models;
         const resident = isResident(pool, key);
         hlog('completion start', { model, resident, projection: Boolean(projectionModel) });
         if (!resident) {
-            await this._makeRoomForCompletion(signal);
-            await this._imageRuntime?.unloadIdle().catch(noop);
-            await this._musicRuntime?.unloadIdle().catch(noop);
+            await this._makeRoomForCompletion(model, { ctxSize: loadOpts.ctxSize, signal });
+            await this._unloadIdleGenerators();
         }
         const acquireRound = async () => {
             if (!isResident(pool, key)) {
-                await this._makeRoomForCompletion(signal);
-                await this._imageRuntime?.unloadIdle().catch(noop);
-                await this._musicRuntime?.unloadIdle().catch(noop);
+                await this._makeRoomForCompletion(model, { ctxSize: loadOpts.ctxSize, signal });
+                await this._unloadIdleGenerators();
             }
             try {
                 const { modelId } = await raceAbort(pool.open(key, model, loadOpts).load(), signal);
@@ -1228,6 +1346,7 @@ export class Harness extends ReadyResource {
             held = false;
             releaseModel(pool, key);
         };
+        this._replying.push(key);
         try {
             const { modelId, ctxSize } = await raceAbort(handle.load(), signal);
             hlog('model ready', { model });
@@ -1287,6 +1406,7 @@ export class Harness extends ReadyResource {
         }
         finally {
             hlog('completion end', { model });
+            this._replying.splice(this._replying.indexOf(key), 1);
             releaseHeld();
             void this._imageRuntime?.unloadIdle().catch(noop);
             void this._musicRuntime?.unloadIdle().catch(noop);
@@ -1315,11 +1435,12 @@ export class Harness extends ReadyResource {
             }
         };
     }
-    async _makeRoomForCompletion(signal, deadlineMs = MODEL_ROOM_WAIT_MS) {
+    async _makeRoomForCompletion(model, { ctxSize, signal, deadlineMs = MODEL_ROOM_WAIT_MS } = {}) {
         const roomed = await awaitModelCapacity(this._models, {
             cap: this._completionModelCap,
             deadlineMs,
-            signal
+            signal,
+            evictable: (key) => !this._pinned.has(key) || modelOf(key) === model
         });
         if (!roomed) {
             hlog('model room wait gave up', {
@@ -1327,6 +1448,7 @@ export class Harness extends ReadyResource {
                 loaded: loadedModels(this._models).length
             });
         }
+        await this._yieldPins(model, ctxSize);
         return roomed;
     }
     async _evictWedgedModel(model, key) {

package/dist-lib/lib/capabilities/preview-model-source.d.ts

@@ -1,7 +1,6 @@
 import type { HarnessPreviewModelSourceResponse } from '../../spec/hyperschema/types.d.ts';
 export type ModelFitVerdict = 'likely-fits' | 'likely-too-large' | 'unknown';
 export type ModelSourceRefusal = 'invalid-source' | 'not-found' | 'private' | 'gated' | 'web-page' | 'unreachable' | 'not-gguf' | 'not-a-model' | 'no-model-files' | 'invalid-projection';
-export type ModelTaskType = 'llm' | 'embeddings' | 'speech-to-text' | 'text-to-speech' | 'image-generation';
 export interface ModelSourceFile {
     src: string;
     label: string;

package/dist-lib/lib/connect.d.ts

@@ -3,7 +3,7 @@ import { type Transport } from './rpc-session.ts';
 import { type KvCacheDeletionResult } from './capabilities/kv-cache.ts';
 import type { CustomModelEntry } from './models/model-catalog.ts';
 import { type ModelSourcePreview, type PreviewModelSourceContext } from './capabilities/preview-model-source.ts';
-import type { CapabilityInfo, CompletionContext, CredentialEntry, DetectedLanguage, DetectLanguageContext, DownloadContext, EmbedContext, HarnessContract, HarnessDiagnostics, HarnessEvent, HarnessInfo, InfraModel, InvokeContext, ListModelsOptions, ModelInfo, ResolvedSkillCatalogEntry, SkillsOptions, SkillWriteResult, SpeakContext, SpeakResult, SpeakStreamContext, ToolCatalogEntry, TranscribeContext, WarmModelContext } from './contract-types.ts';
+import type { CapabilityInfo, CompletionContext, CredentialEntry, DetectedLanguage, DetectLanguageContext, DownloadContext, EmbedContext, HarnessContract, HarnessDiagnostics, HarnessEvent, HarnessInfo, InfraModel, InvokeContext, ListModelsOptions, ModelInfo, ResolvedSkillCatalogEntry, SkillsOptions, SkillWriteResult, SpeakContext, SpeakResult, SpeakStreamContext, ToolCatalogEntry, TranscribeContext, LoadModelContext, LoadModelResult, UnloadModelContext, UnloadModelResult, WarmModelContext } from './contract-types.ts';
 import { type EmbedDevice } from './models/embed-config.ts';
 import type { DeleteModelSummary } from './models/model-delete.ts';
 import type { CopyBaseResult, DeleteOverlayResult, ManagedSkill, SkillFileContent } from './tools/skills/overlay-crud.ts';
@@ -46,6 +46,8 @@ export declare class RemoteHarness extends EventEmitter implements HarnessContra
     skills(agentId?: string | null, modelName?: string | null, options?: SkillsOptions): Promise<ResolvedSkillCatalogEntry[]>;
     tools(): Promise<ToolCatalogEntry[]>;
     warmModel(context: WarmModelContext): Promise<void>;
+    loadModel(context: LoadModelContext): Promise<LoadModelResult>;
+    unloadModel(context: UnloadModelContext): Promise<UnloadModelResult>;
     list(options?: ListModelsOptions): Promise<ModelInfo[]>;
     deleteModel(name: string): Promise<DeleteModelSummary>;
     clearKvCache(): Promise<KvCacheDeletionResult>;

package/dist-lib/lib/connect.js

@@ -8,6 +8,7 @@ import { unsupportedKvCacheDeletion } from './capabilities/kv-cache.js';
 import { readModelSourcePreview } from './capabilities/preview-model-source.js';
 import { hlog } from './log.js';
 import { assertEmbedDevice } from './models/embed-config.js';
+import { addonTaskType } from './models/model-task.js';
 import { errorCode, errorMessage, isRecord } from './guards.js';
 import { pushQueue } from './queue.js';
 import { stageFile, sweepStaging } from './staging.js';
@@ -540,6 +541,24 @@ export class RemoteHarness extends EventEmitter {
             agent: context.agent ? knobs(context.agent) : undefined
         }), context.signal);
     }
+    async loadModel(context) {
+        const { client } = await this._ensure();
+        const response = await abortable(client.loadModel({
+            model: context.model,
+            agent: context.agent ? knobs(context.agent) : undefined
+        }), context.signal);
+        return {
+            loaded: response.loaded === true,
+            reason: response.reason === 'memory' ? 'memory' : undefined
+        };
+    }
+    async unloadModel(context) {
+        const { client } = await this._ensure();
+        const response = await client.unloadModel({
+            model: context.model
+        });
+        return { unloaded: response.unloaded === true };
+    }
     async list(options = {}) {
         const { client } = await this._ensure();
         const response = await client.listModels({
@@ -550,7 +569,8 @@ export class RemoteHarness extends EventEmitter {
         return (response.models ?? []).map(({ actualSize, label, ...row }) => ({
             ...row,
             actualSize: actualSize || undefined,
-            label: label || undefined
+            label: label || undefined,
+            taskType: addonTaskType(row.type)
         }));
     }
     async deleteModel(name) {
@@ -606,7 +626,8 @@ export class RemoteHarness extends EventEmitter {
                     source: memoryBudget.source,
                     gpuClass: memoryBudget.gpuClass || undefined
                 }
-                : undefined
+                : undefined,
+            mobile: response.mobile === true
         };
     }
     close() {

package/dist-lib/lib/contract-types.d.ts

@@ -113,6 +113,17 @@ export interface WarmModelContext {
     agent?: AgentKnobs;
     signal?: CompletionContext['signal'];
 }
+export type LoadModelContext = WarmModelContext;
+export interface LoadModelResult {
+    loaded: boolean;
+    reason?: 'memory';
+}
+export interface UnloadModelContext {
+    model: string;
+}
+export interface UnloadModelResult {
+    unloaded: boolean;
+}
 export interface DownloadContext {
     model: string;
     addon?: string;
@@ -164,6 +175,7 @@ export interface CapabilityInfo {
     capabilityProfile: HarnessCapabilityProfile;
     recommendedModelName: string;
     memoryBudget?: MemoryBudget;
+    mobile: boolean;
 }
 export interface CredentialEntry {
     key: string;
@@ -224,6 +236,8 @@ export interface HarnessContract {
     }>;
     list?(options?: ListModelsOptions): Promise<ModelInfo[]>;
     warmModel?(context: WarmModelContext): Promise<void>;
+    loadModel?(context: LoadModelContext): Promise<LoadModelResult>;
+    unloadModel?(context: UnloadModelContext): Promise<UnloadModelResult>;
     deleteModel?(name: string): Promise<DeleteModelSummary>;
     clearKvCache?(): Promise<KvCacheDeletionResult>;
     deleteKvCache?(kvCacheKey: string): Promise<KvCacheDeletionResult>;

package/dist-lib/lib/docx/index.d.ts

@@ -1,5 +1,5 @@
 import type { AbortSignal } from 'bare-abort-controller';
-export { closePythonWorker as closeDocxWorker } from '../tools/exec/adapters/python/worker/client.ts';
+export { closePythonWorker as closeDocxWorker } from '../tools/exec/adapters/python/worker/active.ts';
 export interface DocxExtractOptions {
     readonly signal?: AbortSignal;
 }

package/dist-lib/lib/docx/index.js

@@ -1,5 +1,5 @@
 import { extractWithPython } from '../office/python.js';
-export { closePythonWorker as closeDocxWorker } from '../tools/exec/adapters/python/worker/client.js';
+export { closePythonWorker as closeDocxWorker } from '../tools/exec/adapters/python/worker/active.js';
 const PACKAGES = ['python-docx==1.2.0'];
 const EXTRACT = `from docx import Document
 from docx.text.paragraph import Paragraph

package/dist-lib/lib/hardware/capability-probe.js

@@ -1,5 +1,5 @@
 import process from 'process';
-import { capabilityProfileToModelName } from '../models/model-catalog.js';
+import { capabilityProfileToModelName, isMobilePlatform } from '../models/model-catalog.js';
 import { probeWithAddon } from './gpu-probe-addon.js';
 import { mobileBudget, parseNvidiaSmiOutput, parseRocmSmiOutput, parseWindowsRegistryOutput, sharedRamBudget } from './parsers.js';
 const GIB = 1024 * 1024 * 1024;
@@ -85,7 +85,7 @@ async function isPixel(reads) {
 }
 async function probeMemoryBudget(reads) {
     const os = reads.platform();
-    if (os === 'android' || os === 'ios') {
+    if (isMobilePlatform(os)) {
         return mobileBudget(reads.totalmem(), await isPixel(reads));
     }
     if (os === 'darwin') {
@@ -101,9 +101,14 @@ function forcedProfile() {
     return undefined;
 }
 export async function probeCapabilityProfile(reads) {
+    const mobile = isMobilePlatform(reads.platform());
     const forced = forcedProfile();
     if (forced) {
-        return { capabilityProfile: forced, recommendedModelName: capabilityProfileToModelName(forced) };
+        return {
+            capabilityProfile: forced,
+            recommendedModelName: capabilityProfileToModelName(forced),
+            mobile
+        };
     }
-    return recommend(await probeMemoryBudget(reads));
+    return { ...recommend(await probeMemoryBudget(reads)), mobile };
 }

package/dist-lib/lib/hooks/built-in/sandbox.js

@@ -1,4 +1,3 @@
-import { planVendoredInstall } from '../../tools/exec/adapters/python/wheels.js';
 import { bareBin, firstCommandToken } from '../../tools/exec/scope.js';
 const NETWORK_BINS = new Set([
     'curl',
@@ -33,10 +32,6 @@ export class SandboxHook {
             return;
         if (!ctx.sandboxMode || ctx.toolName !== 'exec')
             return;
-        const packages = ctx.args.packages;
-        if (Array.isArray(packages) && packages.length && !planVendoredInstall(packages.map(String))) {
-            return { error: 'sandbox mode: installing packages reaches the network', guidance: true };
-        }
         const bin = bareBin(firstCommandToken(String(ctx.args.command ?? '')).replace(/^.*[/\\]/, ''));
         if (bin && NETWORK_BINS.has(bin)) {
             return { error: `sandbox mode: ${bin} reaches the network`, guidance: true };

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

@@ -11,6 +11,13 @@ export declare const MEDPSY_4B = "medpsy-4b-q4_k_m-imat";
 export declare function isCapabilityProfile(value: string): value is CapabilityProfile;
 export declare function meetsMinCapabilityProfile(active: CapabilityProfile, required: CapabilityProfile): boolean;
 export declare function modelNameToCapabilityProfile(modelName: string): CapabilityProfile | undefined;
+export interface HostCapability {
+    readonly capabilityProfile: string;
+    readonly recommendedModelName: string;
+    readonly mobile: boolean;
+}
+export declare function isMobilePlatform(platform: string): boolean;
+export declare function runnableModelName(requested: string, host: HostCapability | null): string;
 export declare function capabilityProfileToModelName(profile: CapabilityProfile): string;
 export declare const AGENT_MODEL_NAMES: readonly ["Qwen3.5-2B-Q4_K_M", "Qwen3.5-4B-Q4_K_M", "Qwen3.5-9B-Q4_K_M", "Qwen3.6-27B-UD-Q4_K_XL", "Qwen3.6-35B-A3B-UD-Q4_K_M", "Qwen3.8-27B-UD-Q4_K_XL", "medpsy-1.7b-q4_k_m-imat", "medpsy-4b-q4_k_m-imat"];
 export declare function modelDisplayName(modelName: string): string;

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

@@ -32,6 +32,23 @@ const MODEL_NAME_TO_PROFILE = new Map([
 export function modelNameToCapabilityProfile(modelName) {
     return MODEL_NAME_TO_PROFILE.get(modelName);
 }
+export function isMobilePlatform(platform) {
+    return platform === 'android' || platform === 'ios';
+}
+export function runnableModelName(requested, host) {
+    if (!host?.mobile || !isCapabilityProfile(host.capabilityProfile)) {
+        return requested;
+    }
+    const required = modelNameToCapabilityProfile(requested);
+    if (!required || meetsMinCapabilityProfile(host.capabilityProfile, required)) {
+        return requested;
+    }
+    const fallback = modelNameToCapabilityProfile(host.recommendedModelName);
+    if (!fallback || !meetsMinCapabilityProfile(required, fallback)) {
+        return requested;
+    }
+    return host.recommendedModelName;
+}
 const PROFILE_TO_MODEL_NAME = new Map([
     ['tiny', QWEN_35_2B],
     ['low', QWEN_35_2B],

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

@@ -5,9 +5,9 @@ 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 };
+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, isMobilePlatform, runnableModelName, type CapabilityProfile, type HostCapability, 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, isMobilePlatform, runnableModelName };
+export type { CapabilityProfile, HostCapability, ImageModelChoice, ImageChoiceEntry };
 export interface LlmCatalogEntry {
     readonly name: string;
     readonly weight: SdkModelAsset;
@@ -49,8 +49,8 @@ export interface DiffusionDownloadMetadata {
 }
 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 };
+import { DEFAULT_MUSIC_MODEL_CHOICE, isMusicModelChoice, musicModelChoiceFrom, type MusicModelChoice } from './music-catalog.ts';
+export { DEFAULT_MUSIC_MODEL_CHOICE, isMusicModelChoice, musicModelChoiceFrom, type MusicModelChoice };
 export interface AudioGenCatalogEntry {
     readonly choice: MusicModelChoice;
     readonly name: string;
@@ -78,7 +78,15 @@ export interface AgentSkillModelInput {
     readonly imageModelChoice?: ImageModelChoice | null;
     readonly musicModelChoice?: MusicModelChoice | null;
 }
-export declare function skillModelsForAgent(agent: AgentSkillModelInput): ReadonlyArray<CatalogModel>;
+export type AgentModelUse = 'chat' | 'image' | 'music';
+export interface AgentModel extends CatalogModel {
+    readonly use: AgentModelUse;
+}
+export interface AgentModelInput extends AgentSkillModelInput {
+    readonly modelName?: string | null;
+}
+export declare function skillModelsForAgent(agent: AgentSkillModelInput): ReadonlyArray<AgentModel>;
+export declare function modelsForAgent(agent: AgentModelInput, host: HostCapability | null): ReadonlyArray<AgentModel>;
 export declare function diffusionSizeBytes(entry: DiffusionCatalogEntry): number;
 export declare function imageModelFor(choice: string | undefined): ImageModelSet | null;
 export interface ImageClamps {
@@ -95,6 +103,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 {