@qvac/harness 0.7.0 → 1.0.0-rc.0

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

@@ -6,28 +6,42 @@ import { defaultContextSize } from './context.js';
 import { customContextLength } from './model-catalog.js';
 import { adrenoSafeKvCache } from './kv-cache.js';
 import { DEFAULT_EMBED_BATCH_SIZE } from './embed-config.js';
+import { errorMessage } from '../guards.js';
 import { hlog } from '../log.js';
 import { RUNAWAY_STOP_SEQUENCES } from '../helpers/control-tokens.js';
 import { raceTimeout } from '../helpers/race-timeout.js';
 import { resolveModelSrc } from './model-source.js';
+export class ModelUnloadError extends Error {
+    constructor(cause) {
+        super(errorMessage(cause));
+        this.name = 'ModelUnloadError';
+    }
+}
 export function createLoadTracker() {
     const inflight = new Set();
-    let draining = null;
+    let draining = false;
+    let drainSdk = null;
     const cancel = (sdk, requestId) => {
+        if (!sdk.cancel) {
+            return;
+        }
         void sdk.cancel({ requestId }).catch(noop);
     };
     return {
         get draining() {
-            return draining !== null;
+            return draining;
         },
-        track(pending) {
+        track(pending, sdk) {
             const { requestId } = pending;
             if (!requestId) {
                 return pending;
             }
             if (draining) {
-                cancel(draining, requestId);
-                return pending;
+                const canceller = sdk ?? drainSdk;
+                if (canceller) {
+                    cancel(canceller, requestId);
+                    return pending;
+                }
             }
             inflight.add(requestId);
             const untrack = () => inflight.delete(requestId);
@@ -35,14 +49,21 @@ export function createLoadTracker() {
             return pending;
         },
         drain(sdk) {
-            draining = sdk;
+            draining = true;
+            if (sdk) {
+                drainSdk = sdk;
+            }
+            if (!drainSdk) {
+                return;
+            }
             for (const requestId of inflight) {
-                cancel(sdk, requestId);
+                cancel(drainSdk, requestId);
             }
             inflight.clear();
         },
         undrain() {
-            draining = null;
+            draining = false;
+            drainSdk = null;
         }
     };
 }
@@ -88,9 +109,10 @@ export function releaseModel(pool, key) {
     void pending.then(() => releaseSettled(pool, key), () => releaseSettled(pool, key));
 }
 function releaseSettled(pool, key) {
-    if (!pool.destroyed) {
-        pool.release(key);
+    if (pool.destroyed) {
+        return;
     }
+    pool.release(key);
 }
 export function loadedModels(pool) {
     const out = [];
@@ -101,6 +123,34 @@ export function loadedModels(pool) {
     }
     return out;
 }
+export function settledModels(pool) {
+    const out = [];
+    for (const entry of pool.resources.values()) {
+        if (entry.value.peek() !== null && !entry.value.loading) {
+            out.push(modelOf(entry.id));
+        }
+    }
+    return out;
+}
+export function loadingModels(pool) {
+    const out = [];
+    for (const entry of pool.resources.values()) {
+        if (entry.value.loading) {
+            out.push(modelOf(entry.id));
+        }
+    }
+    return out;
+}
+function reportedHandle(notify, model, load) {
+    return new ModelHandle({
+        load: () => {
+            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 })
+    });
+}
 export async function leaseResidentModel(pool, wanted = () => true) {
     for (const entry of pool.resources.values()) {
         const key = entry.id;
@@ -289,10 +339,16 @@ export function loadClockGuard(model, sdk, { now = () => Date.now(), monoMs = mo
     };
     return { race };
 }
-export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = createLoadTracker() } = {}) {
+export async function resolveCtxSize(loadSdk, model, opts) {
+    if (opts.ctxSize) {
+        return opts.ctxSize;
+    }
+    const sdk = await loadSdk();
+    return defaultContextSize(await resolveModelSrc(sdk, model));
+}
+export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = createLoadTracker(), onUnloadFailure } = {}) {
     const load = async (model, opts) => {
         const sdk = await loadSdk();
-        notify({ status: 'loading', model });
         const modelSrc = await resolveModelSrc(sdk, model);
         const resolved = resolveLoadOptions(opts, deviceConfig);
         const ctxSize = resolved.ctxSize || defaultContextSize(modelSrc, customContextLength(model));
@@ -330,21 +386,19 @@ export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = cr
             modelType: 'llamacpp-completion',
             modelConfig,
             onProgress: (progress) => notify(progressState(model, progress))
-        })));
+        }), sdk));
         hlog('llm loaded', { model, loadMs: Date.now() - loadStarted });
-        notify({ status: 'ready', model });
         return { model, modelId, ctxSize };
     };
     return new ModelPuddle({
-        open: (key, model = key, opts = {}) => new ModelHandle({ load: () => load(model, opts) }),
-        gc: unloadOnGc(loadSdk, notify),
+        open: (key, model = key, opts = {}) => reportedHandle(notify, model, () => load(model, opts)),
+        gc: unloadOnGc(loadSdk, notify, onUnloadFailure),
         ...NO_IDLE_GC
     });
 }
-export function createEmbedPool(loadSdk, notify, { faults, batchSize = DEFAULT_EMBED_BATCH_SIZE, openclCacheDir, loads = createLoadTracker() }) {
+export function createEmbedPool(loadSdk, notify, { faults, batchSize = DEFAULT_EMBED_BATCH_SIZE, openclCacheDir, loads = createLoadTracker(), onUnloadFailure }) {
     const load = async (model) => {
         const sdk = await loadSdk();
-        notify({ status: 'loading', model });
         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({
@@ -357,22 +411,20 @@ export function createEmbedPool(loadSdk, notify, { faults, batchSize = DEFAULT_E
                 openclCacheDir: openclCache || undefined
             },
             onProgress: (progress) => notify(progressState(model, progress))
-        })));
-        notify({ status: 'ready', model });
+        }), sdk));
         return { model, modelId };
     };
     return new ModelPuddle({
-        open: (key, model = key) => new ModelHandle({ load: () => load(model) }),
-        gc: unloadOnGc(loadSdk, notify),
+        open: (key, model = key) => reportedHandle(notify, model, () => load(model)),
+        gc: unloadOnGc(loadSdk, notify, onUnloadFailure),
         ...NO_IDLE_GC
     });
 }
-export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig, openclCacheDir, loads = createLoadTracker() }) {
+export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig, openclCacheDir, loads = createLoadTracker(), onUnloadFailure }) {
     const wantsGpu = modelConfig?.['useGPU'] === true;
     let gpuRefused = false;
     const load = async (model) => {
         const sdk = await loadSdk();
-        notify({ status: 'loading', model });
         const modelSrc = await resolveModelSrc(sdk, model, addon);
         const attempt = () => {
             const config = gpuRefused ? { ...modelConfig, useGPU: false } : modelConfig;
@@ -382,7 +434,7 @@ export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig
                 modelType,
                 modelConfig: openclCache ? { openclCacheDir: openclCache, ...config } : config,
                 onProgress: (progress) => notify(progressState(model, progress))
-            }));
+            }), sdk);
         };
         const modelId = await loadClockGuard(model, sdk).race(attempt().catch((err) => {
             if (!wantsGpu || gpuRefused || loads.draining)
@@ -391,39 +443,75 @@ export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig
             gpuRefused = true;
             return attempt();
         }));
-        notify({ status: 'ready', model });
         return { model, modelId };
     };
     return new ModelPuddle({
-        open: (key, model = key) => new ModelHandle({ load: () => load(model) }),
-        gc: unloadOnGc(loadSdk, notify),
+        open: (key, model = key) => reportedHandle(notify, model, () => load(model)),
+        gc: unloadOnGc(loadSdk, notify, onUnloadFailure),
         ...NO_IDLE_GC
     });
 }
-function unloadOnGc(loadSdk, notify) {
+function unloadOnGc(loadSdk, notify, onUnloadFailure) {
     return async (handles) => {
-        const sdk = await loadSdk();
+        const loadedHandles = [];
         for (const handle of handles) {
             const pending = handle.peek();
             if (pending === null) {
                 continue;
             }
-            let loaded;
             try {
-                loaded = await pending;
+                loadedHandles.push(await pending);
             }
-            catch {
-                continue;
+            catch { }
+        }
+        if (loadedHandles.length === 0) {
+            return;
+        }
+        const reportFailure = (modelId, error) => {
+            try {
+                onUnloadFailure?.(modelId, error);
+            }
+            catch (callbackError) {
+                hlog('model unload failure observer failed', { error: String(callbackError) });
+            }
+        };
+        let sdk;
+        try {
+            sdk = await loadSdk();
+        }
+        catch (error) {
+            for (const { modelId } of loadedHandles) {
+                reportFailure(modelId, error);
+            }
+            throw new ModelUnloadError(error);
+        }
+        let unloadError;
+        let unloadFailed = false;
+        for (const { model, modelId } of loadedHandles) {
+            try {
+                notify({ status: 'unloading', model });
+            }
+            catch (error) {
+                hlog('model unloading observer failed', { error: String(error) });
             }
-            const { model, modelId } = loaded;
-            notify({ status: 'unloading', model });
             try {
                 await sdk.unloadModel({ modelId });
             }
-            catch {
+            catch (error) {
+                unloadError ??= error;
+                unloadFailed = true;
+                reportFailure(modelId, error);
                 continue;
             }
-            notify({ status: 'unloaded', model });
+            try {
+                notify({ status: 'unloaded', model, catalogChanged: true });
+            }
+            catch (error) {
+                hlog('model unloaded observer failed', { error: String(error) });
+            }
+        }
+        if (unloadFailed) {
+            throw new ModelUnloadError(unloadError);
         }
     };
 }

package/dist-lib/lib/run-log/history-codec.d.ts

@@ -0,0 +1,23 @@
+import { type Patch } from './patch.ts';
+export type { HistoryReference } from './protocol-types.ts';
+export interface HistoryProjectionOptions {
+    base: readonly unknown[] | undefined;
+    failureRefs?: ReadonlySet<string>;
+    validateFailureOutputs?: boolean;
+    validate?: boolean;
+}
+export declare const FAILURE_RESULT_REF_MACHINE_VERSION = 8;
+export declare function requestMessages(request: unknown): readonly unknown[] | undefined;
+export declare function compactSnapshotHistory<Value>(snapshot: Value, base: readonly unknown[] | undefined): Value;
+export declare function materializeSnapshotHistory<Value>(snapshot: Value, base: readonly unknown[] | undefined, allowLegacyInlineFailureResults?: boolean): Value;
+export declare function compactMachineEvent<Value>(event: Value, base: readonly unknown[] | undefined): Value;
+export declare function materializeMachineEvent<Value>(event: Value, base: readonly unknown[] | undefined): Value;
+export interface SnapshotHistoryValidationOptions {
+    allowLegacyInlineFailureResults?: boolean;
+    validateMachineContext?: boolean;
+}
+export declare function validateSnapshotHistory(snapshot: unknown, base: readonly unknown[] | undefined, options?: SnapshotHistoryValidationOptions): void;
+export declare function snapshotFailureResultRefs(snapshot: unknown, allowLegacyInlineFailureResults?: boolean): ReadonlySet<string>;
+export declare function validateMachineEventHistory(event: unknown, base: readonly unknown[] | undefined, failureRefs?: ReadonlySet<string>): void;
+export declare function foldMachineEventHistory(previous: unknown, patch: Patch, options: HistoryProjectionOptions): unknown;
+export declare function validateHistoryProjection(value: unknown, options: HistoryProjectionOptions): void;