@qvac/harness 0.8.5 → 0.8.6

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

@@ -11,6 +11,7 @@ import { RUNAWAY_STOP_SEQUENCES } from '../helpers/control-tokens.js';
 import { raceTimeout } from '../helpers/race-timeout.js';
 import { resolveModelSrc } from './model-source.js';
 import { errorMessage } from '../guards.js';
+import { AbortedError } from '../helpers/race-abort.js';
 export function createLoadTracker() {
     const inflight = new Set();
     let draining = null;
@@ -73,10 +74,14 @@ function entryOf(pool, key) {
 export function modelOf(key) {
     return key.split('\0')[0];
 }
+let uses = 0;
 export function releaseModel(pool, key) {
     if (pool.destroyed)
         return;
     const handle = entryOf(pool, key)?.value;
+    if (handle) {
+        handle.lastUsed = ++uses;
+    }
     if (handle === undefined || !handle.loading) {
         pool.release(key);
         return;
@@ -86,8 +91,18 @@ export function releaseModel(pool, key) {
         pool.release(key);
         return;
     }
-    void pending.then(() => releaseSettled(pool, key), () => releaseSettled(pool, key));
+    const deferred = (deferredReleases.get(handle) ?? 0) + 1;
+    deferredReleases.set(handle, deferred);
+    if (deferred >= (entryOf(pool, key)?.refs ?? 0)) {
+        handle.abandon();
+    }
+    const settle = () => {
+        deferredReleases.set(handle, (deferredReleases.get(handle) ?? 1) - 1);
+        releaseSettled(pool, key);
+    };
+    void pending.then(settle, settle);
 }
+const deferredReleases = new WeakMap();
 function releaseSettled(pool, key) {
     if (!pool.destroyed) {
         pool.release(key);
@@ -111,6 +126,21 @@ export function settledModels(pool) {
     }
     return out;
 }
+export function settledEntries(pool) {
+    const out = [];
+    for (const entry of pool.resources.values()) {
+        const resource = entry.value.resource;
+        if (resource !== null) {
+            out.push({
+                key: entry.id,
+                refs: entry.refs,
+                bytes: resource.bytes,
+                lastUsed: entry.value.lastUsed
+            });
+        }
+    }
+    return out;
+}
 export function loadingModels(pool) {
     const out = [];
     for (const entry of pool.resources.values()) {
@@ -120,14 +150,19 @@ export function loadingModels(pool) {
     }
     return out;
 }
-function reportedHandle(notify, model, load) {
+function reportedHandle({ notify, model, addon, hold, load }) {
     return new ModelHandle({
-        load: () => {
+        load: async (signal) => {
+            await hold?.(model, addon, signal);
             notify({ status: 'loading', model, catalogChanged: true });
             return load();
         },
         onLoaded: () => notify({ status: 'ready', model, catalogChanged: true }),
-        onFailed: (err) => notify({ status: 'error', model, message: errorMessage(err), catalogChanged: true })
+        onFailed: (err) => {
+            if (err instanceof AbortedError)
+                return;
+            notify({ status: 'error', model, message: errorMessage(err), catalogChanged: true });
+        }
     });
 }
 export async function leaseResidentModel(pool, wanted = () => true) {
@@ -226,6 +261,10 @@ export async function awaitModelCapacity(pool, { cap, deadlineMs, tickMs = 250,
 export function evictModelWithin(pool, key, options) {
     return evictWhereWithin(pool, (candidate) => candidate === key, options);
 }
+export function evictIdleWithin(pool, key, { deadlineMs }) {
+    const evicting = evictIdleWhere(pool, (candidate) => candidate === key).then(() => !isResident(pool, key));
+    return raceTimeout(evicting, { ms: deadlineMs, fallback: false });
+}
 export function evictModel(pool, model, options) {
     return evictWhereWithin(pool, (key) => modelOf(key) === model, options);
 }
@@ -318,8 +357,8 @@ export function loadClockGuard(model, sdk, { now = () => Date.now(), monoMs = mo
     };
     return { race };
 }
-export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = createLoadTracker() } = {}) {
-    const load = async (model, opts) => {
+export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = createLoadTracker(), beforeLoad, hold } = {}) {
+    const load = async (key, model, opts) => {
         const sdk = await loadSdk();
         const modelSrc = await resolveModelSrc(sdk, model);
         const resolved = resolveLoadOptions(opts, deviceConfig);
@@ -352,54 +391,80 @@ export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = cr
         });
         const { projectionModelSrc: projection, ...loggedConfig } = modelConfig;
         hlog('llm load config', { model, projection: Boolean(projection), ...loggedConfig });
+        const admission = await beforeLoad?.({
+            key,
+            model,
+            modelSrc,
+            modelType: 'llamacpp-completion',
+            modelConfig
+        });
         const loadStarted = Date.now();
-        const modelId = await loadClockGuard(model, sdk).race(loads.track(sdk.loadModel({
+        const modelId = await loadClockGuard(model, sdk)
+            .race(loads.track(sdk.loadModel({
             modelSrc,
             modelType: 'llamacpp-completion',
             modelConfig,
             onProgress: (progress) => notify(progressState(model, progress))
-        })));
+        })))
+            .finally(() => admission?.release());
         hlog('llm loaded', { model, loadMs: Date.now() - loadStarted });
-        return { model, modelId, ctxSize };
+        return { model, modelId, ctxSize, bytes: admission?.bytes };
     };
     return new ModelPuddle({
-        open: (key, model = key, opts = {}) => reportedHandle(notify, model, () => load(model, opts)),
+        open: (key, model = key, opts = {}) => reportedHandle({ notify, model, addon: 'llm', hold, load: () => load(key, model, opts) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
     });
 }
-export function createEmbedPool(loadSdk, notify, { faults, batchSize = DEFAULT_EMBED_BATCH_SIZE, openclCacheDir, loads = createLoadTracker() }) {
-    const load = async (model) => {
+export function createEmbedPool(loadSdk, notify, { faults, batchSize = DEFAULT_EMBED_BATCH_SIZE, openclCacheDir, loads = createLoadTracker(), beforeLoad, hold }) {
+    const load = async (key, model) => {
         const sdk = await loadSdk();
         const modelSrc = await resolveModelSrc(sdk, model, 'embeddings');
         const openclCache = faults.device !== 'cpu' && openclCacheDir ? openclCacheDir() : undefined;
-        const modelId = await loadClockGuard(model, sdk).race(loads.track(sdk.loadModel({
+        const modelConfig = {
+            batchSize,
+            gpuLayers: faults.gpuLayers(),
+            device: faults.device,
+            openclCacheDir: openclCache || undefined
+        };
+        const admission = await beforeLoad?.({
+            key,
+            model,
             modelSrc,
             modelType: 'llamacpp-embedding',
-            modelConfig: {
-                batchSize,
-                gpuLayers: faults.gpuLayers(),
-                device: faults.device,
-                openclCacheDir: openclCache || undefined
-            },
+            modelConfig
+        });
+        const modelId = await loadClockGuard(model, sdk)
+            .race(loads.track(sdk.loadModel({
+            modelSrc,
+            modelType: 'llamacpp-embedding',
+            modelConfig,
             onProgress: (progress) => notify(progressState(model, progress))
-        })));
-        return { model, modelId };
+        })))
+            .finally(() => admission?.release());
+        return { model, modelId, bytes: admission?.bytes };
     };
     return new ModelPuddle({
-        open: (key, model = key) => reportedHandle(notify, model, () => load(model)),
+        open: (key, model = key) => reportedHandle({ notify, model, addon: 'embeddings', hold, load: () => load(key, model) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
     });
 }
-export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig, modelConfigFor, openclCacheDir, loads = createLoadTracker() }) {
+export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig, modelConfigFor, openclCacheDir, loads = createLoadTracker(), beforeLoad, hold }) {
     const wantsGpu = modelConfig?.['useGPU'] === true;
     let gpuRefused = false;
-    const load = async (model) => {
+    const load = async (key, model) => {
         const sdk = await loadSdk();
         const modelSrc = await resolveModelSrc(sdk, model, addon);
         const tuned = modelConfigFor?.(modelSrc);
         const loadConfig = tuned ? { ...modelConfig, ...tuned } : modelConfig;
+        const admission = await beforeLoad?.({
+            key,
+            model,
+            modelSrc,
+            modelType,
+            modelConfig: loadConfig
+        });
         const attempt = () => {
             const config = gpuRefused ? { ...loadConfig, useGPU: false } : loadConfig;
             const openclCache = gpuRefused ? undefined : openclCacheDir?.();
@@ -410,17 +475,19 @@ export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig
                 onProgress: (progress) => notify(progressState(model, progress))
             }));
         };
-        const modelId = await loadClockGuard(model, sdk).race(attempt().catch((err) => {
+        const modelId = await loadClockGuard(model, sdk)
+            .race(attempt().catch((err) => {
             if (!wantsGpu || gpuRefused || loads.draining)
                 throw err;
             hlog('voice gpu load refused, retrying on cpu', { model, modelType, error: String(err) });
             gpuRefused = true;
             return attempt();
-        }));
-        return { model, modelId };
+        }))
+            .finally(() => admission?.release());
+        return { model, modelId, bytes: admission?.bytes };
     };
     return new ModelPuddle({
-        open: (key, model = key) => reportedHandle(notify, model, () => load(model)),
+        open: (key, model = key) => reportedHandle({ notify, model, addon, hold, load: () => load(key, model) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
     });
@@ -445,7 +512,8 @@ function unloadOnGc(loadSdk, notify) {
             try {
                 await sdk.unloadModel({ modelId });
             }
-            catch {
+            catch (err) {
+                hlog('unload failed', { model, err: errorMessage(err) });
                 continue;
             }
             notify({ status: 'unloaded', model, catalogChanged: true });

package/dist-lib/lib/serve.js

@@ -23,7 +23,8 @@ const MODEL_STATUSES = new Set([
     'ready',
     'error',
     'unloading',
-    'unloaded'
+    'unloaded',
+    'held'
 ]);
 const DOWNLOAD_PROGRESS_INTERVAL_MS = 500;
 const WIRE_HIGH_WATER_MARK = 64;
@@ -50,6 +51,20 @@ export function serveHarness(stream, harness) {
             await harness.setModelIdleTimeout?.(ms);
             return { ok: true };
         },
+        setModelMemoryCap: async ({ percent }) => {
+            await harness.setModelMemoryCap?.(percent);
+            return { ok: true };
+        },
+        memoryUsage: async () => {
+            if (!harness.memoryUsage) {
+                throw new Error('harness does not support memoryUsage');
+            }
+            return harness.memoryUsage();
+        },
+        setDownloadsAllowed: async ({ allowed }) => {
+            await harness.setDownloadsAllowed?.({ allowed: allowed === true });
+            return { ok: true };
+        },
         listManagedSkills: async () => ({
             skills: (await harness.listManagedSkills?.()) ?? []
         }),
@@ -282,7 +297,8 @@ function modelEvents(harness) {
             total,
             message: state.message,
             catalogChanged,
-            loaded
+            loaded,
+            addon: state.addon
         };
         const now = Date.now();
         if (state.status === 'downloading') {

package/dist-lib/lib/tools/generate-image.d.ts

@@ -3,6 +3,7 @@ import type { ToolDefinition } from '../capabilities/completion.ts';
 import type { ModelSrc } from '../models/context.ts';
 import { type ImageClamps } from '../models/model-catalog.ts';
 import { type LoadTracker, type TrackedLoad } from '../models/model-pool.ts';
+import type { HoldFn } from '../models/download-gate.ts';
 import { type ModelRegistrySdk } from '../models/model-source.ts';
 export declare const MAX_DIM = 1024;
 export declare const DIM_STEP = 64;
@@ -68,7 +69,8 @@ export interface DiffusionRuntimeOptions extends ImageModelSet {
     loadSdk: () => Promise<DiffusionSdk>;
     onProgress?: (model: string, progress: Record<string, unknown>) => void;
     onLoaded?: (model: string) => void;
-    onBeforeLoad?: (signal?: BareAbortSignal) => Promise<void>;
+    onBeforeLoad?: (signal: BareAbortSignal | undefined, srcs: ReadonlyArray<string>) => Promise<void>;
+    hold?: HoldFn;
     loads?: LoadTracker;
     stallMs?: number;
 }
@@ -87,7 +89,7 @@ export interface DiffusionRuntime {
 }
 export declare function generationPercentTick(onPercent: (percentage: number) => void, encodePhases?: number): (tick: DiffusionTick) => void;
 export declare const IMAGE_LOAD_STALL_ERROR = "image model download stalled";
-export declare function createDiffusionRuntime({ loadSdk, onProgress, onLoaded, onBeforeLoad, loads, stallMs, ...base }: DiffusionRuntimeOptions): DiffusionRuntime;
+export declare function createDiffusionRuntime({ loadSdk, onProgress, onLoaded, onBeforeLoad, hold, loads, stallMs, ...base }: DiffusionRuntimeOptions): DiffusionRuntime;
 export declare const BUSY_ERROR = "an image generation is already running; try again when it finishes";
 export interface ImageToolError {
     error: string;

package/dist-lib/lib/tools/generate-image.js

@@ -39,7 +39,7 @@ function diffusionProgressName(set) {
     return entry?.name ?? set.model;
 }
 export const IMAGE_LOAD_STALL_ERROR = 'image model download stalled';
-export function createDiffusionRuntime({ loadSdk, onProgress, onLoaded, onBeforeLoad, loads = createLoadTracker(), stallMs = IMAGE_LOAD_STALL_MS, ...base }) {
+export function createDiffusionRuntime({ loadSdk, onProgress, onLoaded, onBeforeLoad, hold, loads = createLoadTracker(), stallMs = IMAGE_LOAD_STALL_MS, ...base }) {
     let loading = null;
     let residentFingerprint = null;
     let busy = false;
@@ -76,13 +76,16 @@ export function createDiffusionRuntime({ loadSdk, onProgress, onLoaded, onBefore
         ensureLoaded: async (sdk, signal, modelChoice) => {
             const set = (modelChoice && imageModelFor(modelChoice)) || base;
             const fingerprint = fingerprintOf(set);
+            if (hold && !(loading && residentFingerprint === fingerprint)) {
+                await hold(diffusionProgressName(set), 'diffusion', signal);
+            }
             await lock.lock();
             try {
                 if (loading && residentFingerprint !== fingerprint) {
                     await doUnload();
                 }
                 if (!loading && onBeforeLoad) {
-                    await onBeforeLoad(signal);
+                    await onBeforeLoad(signal, [set.model, set.llmModel, set.vaeModel].filter((src) => src !== undefined));
                 }
                 residentFingerprint = fingerprint;
                 loading ??= (async () => {

package/dist-lib/lib/tools/generate-music.d.ts

@@ -2,6 +2,7 @@ import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { MusicSettings, ToolDefinition, ToolExecuteContext } from '../capabilities/completion.ts';
 import type { ModelSrc } from '../models/context.ts';
 import { type LoadTracker, type TrackedLoad } from '../models/model-pool.ts';
+import type { HoldFn } from '../models/download-gate.ts';
 import { type ModelRegistrySdk } from '../models/model-source.ts';
 export declare const MAX_DURATION_SECONDS = 300;
 export declare const MIN_DURATION_SECONDS = 1;
@@ -75,7 +76,8 @@ export interface MusicRuntimeOptions extends MusicModelStages {
     inferenceSteps?: number;
     useGpu?: boolean;
     onProgress?: (model: string, progress: Record<string, unknown>) => void;
-    onBeforeLoad?: (signal?: BareAbortSignal) => Promise<void>;
+    onBeforeLoad?: (signal: BareAbortSignal | undefined, srcs: ReadonlyArray<string>) => Promise<void>;
+    hold?: HoldFn;
     loads?: LoadTracker;
 }
 export interface LoadedMusicModel {
@@ -97,7 +99,7 @@ export interface MusicRuntime {
     release(): void;
 }
 export declare function musicPercentTick(onPercent: (percentage: number) => void): (tick: MusicTick) => void;
-export declare function createMusicRuntime({ loadSdk, onProgress, onBeforeLoad, loads, inferenceSteps: baseSteps, useGpu, ...base }: MusicRuntimeOptions): MusicRuntime;
+export declare function createMusicRuntime({ loadSdk, onProgress, onBeforeLoad, hold, loads, inferenceSteps: baseSteps, useGpu, ...base }: MusicRuntimeOptions): MusicRuntime;
 export declare const BUSY_ERROR = "a music generation is already running; try again when it finishes";
 export interface MusicToolError {
     error: string;

package/dist-lib/lib/tools/generate-music.js

@@ -49,7 +49,7 @@ function musicProgressName(dit) {
     const entry = AUDIOGEN_CATALOG.find((candidate) => candidate.dit.src === dit || candidate.dit.name === dit);
     return entry?.name ?? dit;
 }
-export function createMusicRuntime({ loadSdk, onProgress, onBeforeLoad, loads = createLoadTracker(), inferenceSteps: baseSteps, useGpu = true, ...base }) {
+export function createMusicRuntime({ loadSdk, onProgress, onBeforeLoad, hold, loads = createLoadTracker(), inferenceSteps: baseSteps, useGpu = true, ...base }) {
     let loading = null;
     let residentFingerprint = null;
     let busy = false;
@@ -89,13 +89,16 @@ export function createMusicRuntime({ loadSdk, onProgress, onBeforeLoad, loads =
             const stages = stagesFor(modelChoice, base);
             const effectiveSteps = steps ?? baseSteps;
             const fingerprint = fingerprintOf(stages, effectiveSteps);
+            if (hold && !(loading && residentFingerprint === fingerprint)) {
+                await hold(musicProgressName(stages.dit), 'audiogen', signal);
+            }
             await lock.lock();
             try {
                 if (loading && residentFingerprint !== fingerprint) {
                     await doUnload();
                 }
                 if (!loading && onBeforeLoad) {
-                    await onBeforeLoad(signal);
+                    await onBeforeLoad(signal, [stages.dit, stages.textEnc, stages.lm, stages.vae]);
                 }
                 residentFingerprint = fingerprint;
                 loading ??= (async () => {

package/dist-lib/lib/tools/translate.d.ts

@@ -3,6 +3,7 @@ import type { ToolDefinition } from '../capabilities/completion.ts';
 import type { ModelSrc } from '../models/context.ts';
 import { type NmtPlan } from '../models/nmt-catalog.ts';
 import { type LoadTracker, type TrackedLoad } from '../models/model-pool.ts';
+import type { HoldFn } from '../models/download-gate.ts';
 import { type ModelRegistrySdk } from '../models/model-source.ts';
 interface BergamotConfig {
     engine: 'Bergamot';
@@ -42,6 +43,7 @@ export interface TranslationRuntimeOptions {
     loadSdk: () => Promise<TranslationSdk>;
     loads?: LoadTracker;
     onProgress?: (model: string, progress: Record<string, unknown>) => void;
+    hold?: HoldFn;
     stallMs?: number;
 }
 export interface TranslationRuntime {
@@ -53,7 +55,7 @@ export interface TranslationRuntime {
     enter: (signal?: BareAbortSignal) => Promise<void>;
     exit: () => void;
 }
-export declare function createTranslationRuntime({ loadSdk, loads, onProgress, stallMs }: TranslationRuntimeOptions): TranslationRuntime;
+export declare function createTranslationRuntime({ loadSdk, loads, onProgress, hold, stallMs }: TranslationRuntimeOptions): TranslationRuntime;
 export type SlmTranslateFn = (model: string, params: {
     text: string;
     from: string;

package/dist-lib/lib/tools/translate.js

@@ -26,7 +26,7 @@ function bergamotConfig(plan) {
     }
     return config;
 }
-export function createTranslationRuntime({ loadSdk, loads = createLoadTracker(), onProgress, stallMs = TRANSLATION_LOAD_STALL_MS }) {
+export function createTranslationRuntime({ loadSdk, loads = createLoadTracker(), onProgress, hold, stallMs = TRANSLATION_LOAD_STALL_MS }) {
     let loading = null;
     let residentFingerprint = null;
     const lock = new ScopeLock();
@@ -95,6 +95,11 @@ export function createTranslationRuntime({ loadSdk, loads = createLoadTracker(),
         loadSdk,
         ensureLoaded: async (sdk, plan, signal) => {
             const fingerprint = fingerprintOf(plan);
+            if (hold && !(loading && residentFingerprint === fingerprint)) {
+                for (const model of plan.pivot ? [plan.model, plan.pivot] : [plan.model]) {
+                    await hold(model, 'nmt', signal);
+                }
+            }
             await lock.lock();
             try {
                 if (loading && residentFingerprint !== fingerprint) {

package/dist-lib/schema/harness.js

@@ -175,7 +175,16 @@ export function registerHarnessTypes(ns) {
     });
     ns.register({
         name: 'model-event-status',
-        enum: ['loading', 'downloading', 'ready', 'error', 'unloading', 'unloaded', 'downloaded'],
+        enum: [
+            'loading',
+            'downloading',
+            'ready',
+            'error',
+            'unloading',
+            'unloaded',
+            'downloaded',
+            'held'
+        ],
         strings: true
     });
     ns.register({
@@ -195,7 +204,8 @@ export function registerHarnessTypes(ns) {
             { name: 'loaded', type: '@harness/loaded-model', array: true },
             { name: 'catalogChanged', type: 'bool' },
             { name: 'downloaded', type: 'uint' },
-            { name: 'total', type: 'uint' }
+            { name: 'total', type: 'uint' },
+            { name: 'addon', type: 'string' }
         ]
     });
     ns.register({
@@ -340,7 +350,8 @@ export function registerHarnessTypes(ns) {
             { name: 'expectedSize', type: 'uint', required: true },
             { name: 'actualSize', type: 'uint' },
             { name: 'label', type: 'string' },
-            { name: 'isLoading', type: 'bool' }
+            { name: 'isLoading', type: 'bool' },
+            { name: 'memoryBytes', type: 'uint' }
         ]
     });
     ns.register({
@@ -738,6 +749,18 @@ export function registerHarnessTypes(ns) {
         name: 'unload-model-response',
         fields: [{ name: 'unloaded', type: 'bool', required: true }]
     });
+    ns.register({
+        name: 'set-model-memory-cap-request',
+        fields: [{ name: 'percent', type: 'uint', required: true }]
+    });
+    ns.register({
+        name: 'memory-usage',
+        fields: [{ name: 'usedBytes', type: 'uint', required: true }]
+    });
+    ns.register({
+        name: 'set-downloads-allowed-request',
+        fields: [{ name: 'allowed', type: 'bool', required: true }]
+    });
 }
 export function registerHarnessApi(api) {
     api.register({
@@ -905,4 +928,19 @@ export function registerHarnessApi(api) {
         request: { name: '@harness/unload-model-request', stream: false },
         response: { name: '@harness/unload-model-response', stream: false }
     });
+    api.register({
+        name: 'set-model-memory-cap',
+        request: { name: '@harness/set-model-memory-cap-request', stream: false },
+        response: { name: '@harness/ok-response', stream: false }
+    });
+    api.register({
+        name: 'memory-usage',
+        request: { name: '@harness/empty', stream: false },
+        response: { name: '@harness/memory-usage', stream: false }
+    });
+    api.register({
+        name: 'set-downloads-allowed',
+        request: { name: '@harness/set-downloads-allowed-request', stream: false },
+        response: { name: '@harness/ok-response', stream: false }
+    });
 }

package/dist-lib/spec/bind.js

@@ -139,4 +139,13 @@ export function bindApi(rpc, api) {
   if (api.unloadModel) {
     rpc.onUnloadModel((req) => api.unloadModel(req));
   }
+  if (api.setModelMemoryCap) {
+    rpc.onSetModelMemoryCap((req) => api.setModelMemoryCap(req));
+  }
+  if (api.memoryUsage) {
+    rpc.onMemoryUsage((req) => api.memoryUsage(req));
+  }
+  if (api.setDownloadsAllowed) {
+    rpc.onSetDownloadsAllowed((req) => api.setDownloadsAllowed(req));
+  }
 }

package/dist-lib/spec/calls.js

@@ -43,5 +43,8 @@ export function harnessClient(rpc) {
     setModelIdleTimeout: (input) => rpc.setModelIdleTimeout(input),
     loadModel: (input) => rpc.loadModel(input),
     unloadModel: (input) => rpc.unloadModel(input),
+    setModelMemoryCap: (input) => rpc.setModelMemoryCap(input),
+    memoryUsage: (input) => rpc.memoryUsage(input),
+    setDownloadsAllowed: (input) => rpc.setDownloadsAllowed(input),
   };
 }

package/dist-lib/spec/hrpc/hrpc.json

@@ -429,6 +429,45 @@
         "stream": false
       },
       "version": 1
+    },
+    {
+      "id": 33,
+      "name": "@harness/set-model-memory-cap",
+      "request": {
+        "name": "@harness/set-model-memory-cap-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@harness/ok-response",
+        "stream": false
+      },
+      "version": 1
+    },
+    {
+      "id": 34,
+      "name": "@harness/memory-usage",
+      "request": {
+        "name": "@harness/empty",
+        "stream": false
+      },
+      "response": {
+        "name": "@harness/memory-usage",
+        "stream": false
+      },
+      "version": 1
+    },
+    {
+      "id": 35,
+      "name": "@harness/set-downloads-allowed",
+      "request": {
+        "name": "@harness/set-downloads-allowed-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@harness/ok-response",
+        "stream": false
+      },
+      "version": 1
     }
   ]
 }

package/dist-lib/spec/hrpc/index.js

@@ -71,7 +71,13 @@ const methods = new Map([
   ['@harness/load-model', 31],
   [31, '@harness/load-model'],
   ['@harness/unload-model', 32],
-  [32, '@harness/unload-model']
+  [32, '@harness/unload-model'],
+  ['@harness/set-model-memory-cap', 33],
+  [33, '@harness/set-model-memory-cap'],
+  ['@harness/memory-usage', 34],
+  [34, '@harness/memory-usage'],
+  ['@harness/set-downloads-allowed', 35],
+  [35, '@harness/set-downloads-allowed']
 ])
 
 class HRPC {
@@ -111,7 +117,10 @@ class HRPC {
       ['@harness/preview-model-source', getEncoding('@harness/preview-model-source-request')],
       ['@harness/set-model-idle-timeout', getEncoding('@harness/set-model-idle-timeout-request')],
       ['@harness/load-model', getEncoding('@harness/warm-model-request')],
-      ['@harness/unload-model', getEncoding('@harness/unload-model-request')]
+      ['@harness/unload-model', getEncoding('@harness/unload-model-request')],
+      ['@harness/set-model-memory-cap', getEncoding('@harness/set-model-memory-cap-request')],
+      ['@harness/memory-usage', getEncoding('@harness/empty')],
+      ['@harness/set-downloads-allowed', getEncoding('@harness/set-downloads-allowed-request')]
     ])
     this._responseEncodings = new Map([
       ['@harness/completion', getEncoding('@harness/completion-event')],
@@ -146,7 +155,10 @@ class HRPC {
       ['@harness/preview-model-source', getEncoding('@harness/preview-model-source-response')],
       ['@harness/set-model-idle-timeout', getEncoding('@harness/ok-response')],
       ['@harness/load-model', getEncoding('@harness/load-model-response')],
-      ['@harness/unload-model', getEncoding('@harness/unload-model-response')]
+      ['@harness/unload-model', getEncoding('@harness/unload-model-response')],
+      ['@harness/set-model-memory-cap', getEncoding('@harness/ok-response')],
+      ['@harness/memory-usage', getEncoding('@harness/memory-usage')],
+      ['@harness/set-downloads-allowed', getEncoding('@harness/ok-response')]
     ])
     this._rpc = new RPC(stream, async (req) => {
       const command = methods.get(req.command)
@@ -376,6 +388,18 @@ class HRPC {
     return this._call('@harness/unload-model', args)
   }
 
+  async setModelMemoryCap(args) {
+    return this._call('@harness/set-model-memory-cap', args)
+  }
+
+  async memoryUsage(args) {
+    return this._call('@harness/memory-usage', args)
+  }
+
+  async setDownloadsAllowed(args) {
+    return this._call('@harness/set-downloads-allowed', args)
+  }
+
   onCompletion(responseFn) {
     this._handlers['@harness/completion'] = responseFn
   }
@@ -508,6 +532,18 @@ class HRPC {
     this._handlers['@harness/unload-model'] = responseFn
   }
 
+  onSetModelMemoryCap(responseFn) {
+    this._handlers['@harness/set-model-memory-cap'] = responseFn
+  }
+
+  onMemoryUsage(responseFn) {
+    this._handlers['@harness/memory-usage'] = responseFn
+  }
+
+  onSetDownloadsAllowed(responseFn) {
+    this._handlers['@harness/set-downloads-allowed'] = responseFn
+  }
+
   _requestIsStream(command) {
     return [
       '@harness/completion',