@qvac/harness 0.4.0 → 0.6.0

package/dist-lib/lib/hooks/built-in/arg-repair.js

@@ -1,4 +1,5 @@
 import { jsonrepair } from 'jsonrepair';
+import { isRecord } from '../../guards.js';
 import { hlog } from '../../log.js';
 const STRUCTURED_TYPES = new Set(['object', 'array']);
 export class ArgRepairHook {
@@ -9,11 +10,13 @@ export class ArgRepairHook {
         let args = ctx.args;
         for (const [key, schema] of Object.entries(ctx.parameters.properties)) {
             const value = args[key];
-            if (typeof value !== 'string')
+            if (typeof value !== 'string') {
                 continue;
+            }
             const types = structuredTypes(schema);
-            if (types.size === 0)
+            if (types.size === 0) {
                 continue;
+            }
             const parsed = parseStructured(value, types);
             if (parsed === null) {
                 hlog('arg repair declined', { tool: ctx.toolName, param: key, length: value.length });
@@ -21,8 +24,9 @@ export class ArgRepairHook {
             }
             args = { ...args, [key]: parsed };
         }
-        if (args !== ctx.args)
+        if (args !== ctx.args) {
             return { args };
+        }
     }
 }
 function parseStructured(value, types) {
@@ -36,16 +40,18 @@ function parseStructured(value, types) {
         return null;
     }
     const accepted = accept(parsed, types);
-    if (accepted !== null)
+    if (accepted !== null) {
         return accepted;
+    }
     if (Array.isArray(parsed) &&
         types.has('object') &&
-        isRecord(parsed[0]) &&
+        isPlainObject(parsed[0]) &&
         typeof parsed.at(-1) === 'string') {
         return parsed[0];
     }
-    if (text[0] === '"' && types.has('object'))
+    if (text[0] === '"' && types.has('object')) {
         return accept(read(`{${text}}`), types);
+    }
     return null;
 }
 function read(text) {
@@ -57,7 +63,7 @@ function read(text) {
     }
 }
 function accept(value, types) {
-    if (isRecord(value) && types.has('object'))
+    if (isPlainObject(value) && types.has('object'))
         return value;
     if (Array.isArray(value) && types.has('array'))
         return value;
@@ -65,24 +71,28 @@ function accept(value, types) {
 }
 function structuredTypes(schema) {
     const found = new Set();
-    if (!isRecord(schema))
+    if (!isPlainObject(schema)) {
         return found;
+    }
     const declared = Array.isArray(schema.type) ? schema.type : [schema.type];
     for (const type of declared) {
-        if (typeof type === 'string' && STRUCTURED_TYPES.has(type))
+        if (typeof type === 'string' && STRUCTURED_TYPES.has(type)) {
             found.add(type);
+        }
     }
     for (const key of ['oneOf', 'anyOf']) {
         const branches = schema[key];
-        if (!Array.isArray(branches))
+        if (!Array.isArray(branches)) {
             continue;
+        }
         for (const branch of branches) {
-            for (const type of structuredTypes(branch))
+            for (const type of structuredTypes(branch)) {
                 found.add(type);
+            }
         }
     }
     return found;
 }
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+function isPlainObject(value) {
+    return isRecord(value) && !Array.isArray(value);
 }

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

@@ -23,7 +23,8 @@ export class EgressGuardHook {
             return;
         }
         const blocked = checkOutboundHost(url);
-        if (blocked)
+        if (blocked) {
             return { error: blocked, guidance: true };
+        }
     }
 }

package/dist-lib/lib/hooks/built-in/skill-catalog.js

@@ -11,8 +11,9 @@ export class SkillCatalogGuardHook {
         const known = new Set(entries.map((entry) => (typeof entry === 'string' ? entry : entry.name)));
         const raw = ctx.args.name ?? ctx.args.skill_name ?? ctx.args.skill;
         const name = typeof raw === 'string' ? raw : '';
-        if (known.has(name))
+        if (known.has(name)) {
             return;
+        }
         const listed = [...known].join(', ');
         const rest = listed
             ? `The only skills are: ${listed}. Nothing else needs a skill load — answer or act with the tools you already have.`

package/dist-lib/lib/hooks/pipeline.d.ts

@@ -7,14 +7,15 @@ export type PreToolFold = {
     ok: false;
     rejection: HookRejection;
 };
+export interface PostToolFold {
+    result: unknown;
+    outcome?: ToolExecutionOutcome;
+}
 export declare class HookPipeline {
     private readonly _behaviorHooks;
     constructor(hooks?: readonly HarnessHook[]);
     onRunStart(payload: Omit<RunStartPayload, 'phase'>): Promise<void>;
     onRunEnd(payload: Omit<RunEndPayload, 'phase'>): Promise<void>;
     runPreToolFold(payload: Omit<PreToolCallPayload, 'phase'>): Promise<PreToolFold>;
-    runPostToolFold(payload: Omit<PostToolCallPayload, 'phase'>): Promise<{
-        result: unknown;
-        outcome?: ToolExecutionOutcome;
-    }>;
+    runPostToolFold(payload: Omit<PostToolCallPayload, 'phase'>): Promise<PostToolFold>;
 }

package/dist-lib/lib/hooks/pipeline.js

@@ -9,13 +9,15 @@ export class HookPipeline {
     }
     async onRunStart(payload) {
         const folded = await runHooks(this._behaviorHooks, { phase: 'runStart', ...payload });
-        if ('guidance' in folded)
+        if ('guidance' in folded) {
             hlog('run hook failed', { stage: 'runStart', error: folded.error });
+        }
     }
     async onRunEnd(payload) {
         const folded = await runHooks(this._behaviorHooks, { phase: 'runEnd', ...payload });
-        if ('guidance' in folded)
+        if ('guidance' in folded) {
             hlog('run hook failed', { stage: 'runEnd', error: folded.error });
+        }
     }
     async runPreToolFold(payload) {
         const folded = await runHooks(this._behaviorHooks, { phase: 'preToolCall', ...payload });
@@ -42,8 +44,9 @@ export class HookPipeline {
                 result = folded.result;
             }
         }
-        if (outcome !== undefined)
+        if (outcome !== undefined) {
             outcome = normalizeToolExecutionOutcome(result, outcome);
+        }
         return { result, outcome };
     }
 }

package/dist-lib/lib/hooks/run.js

@@ -1,3 +1,4 @@
+import { errorMessage, isRecord } from '../guards.js';
 import { hlog } from '../log.js';
 function cloneJson(value) {
     try {
@@ -8,19 +9,20 @@ function cloneJson(value) {
         return value;
     }
 }
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+function isPlainObject(value) {
+    return isRecord(value) && !Array.isArray(value);
 }
 function cloneArgs(args) {
     const cloned = cloneJson(args);
-    return isRecord(cloned) ? cloned : args;
+    return isPlainObject(cloned) ? cloned : args;
 }
 function isMessage(value) {
-    return isRecord(value) && typeof value.role === 'string' && typeof value.content === 'string';
+    return isPlainObject(value) && typeof value.role === 'string' && typeof value.content === 'string';
 }
 function freshContext(ctx) {
-    if (ctx.phase === 'preToolCall')
+    if (ctx.phase === 'preToolCall') {
         return { ...ctx, args: cloneArgs(ctx.args) };
+    }
     if (ctx.phase === 'postToolCall') {
         return { ...ctx, args: cloneArgs(ctx.args), result: cloneJson(ctx.result) };
     }
@@ -52,7 +54,7 @@ function merge(current, returned) {
     return current;
 }
 function rejectionOf(current, err) {
-    const message = err instanceof Error ? err.message : String(err);
+    const message = errorMessage(err);
     hlog('hook failed', { stage: current.phase, error: message });
     if (current.phase === 'postToolCall') {
         return {
@@ -69,10 +71,12 @@ export async function runHooks(hooks, ctx) {
             continue;
         try {
             const returned = await hook.run(freshContext(current));
-            if (!returned || typeof returned !== 'object')
+            if (!returned || typeof returned !== 'object') {
                 continue;
-            if (isRejection(returned))
+            }
+            if (isRejection(returned)) {
                 return rejection(returned);
+            }
             current = merge(current, returned);
         }
         catch (err) {

package/dist-lib/lib/model-download-progress.js

@@ -1,20 +1,24 @@
+import { isRecord } from './guards.js';
 const EMA_WEIGHT = 0.25;
 const STALL_MS = 2_000;
 const NO_BYTES = { downloaded: 0, total: 0, aggregate: false };
 export function transferProgress(event) {
     const aggregate = aggregateTransfer(event.fileSetInfo) ?? aggregateTransfer(event.shardInfo);
-    if (aggregate)
+    if (aggregate) {
         return aggregate;
+    }
     const bytes = { downloaded: uint(event.downloaded), total: uint(event.total), aggregate: false };
     const reported = reportedPercentage(event.percentage);
-    if (reported === null && bytes.downloaded === 0 && bytes.total === 0)
+    if (reported === null && bytes.downloaded === 0 && bytes.total === 0) {
         return null;
+    }
     return { ...bytes, percentage: resolvePercentage(reported, bytes) };
 }
 export function progressBytes(event) {
     const transfer = transferProgress(event);
-    if (!transfer)
+    if (!transfer) {
         return NO_BYTES;
+    }
     return {
         downloaded: transfer.downloaded,
         total: transfer.total,
@@ -34,8 +38,9 @@ export class DownloadSpeedSampler {
             return 0;
         }
         const elapsedMs = at - this._at;
-        if (elapsedMs <= 0)
+        if (elapsedMs <= 0) {
             return Math.round(this._bytesPerSecond);
+        }
         const delta = bytes.downloaded - this._downloaded;
         if (delta === 0) {
             if (elapsedMs >= STALL_MS) {
@@ -62,7 +67,7 @@ export class DownloadSpeedSampler {
     }
 }
 function aggregateTransfer(value) {
-    if (!record(value))
+    if (!isRecord(value))
         return null;
     const bytes = {
         downloaded: uint(value.overallDownloaded),
@@ -84,9 +89,6 @@ function reportedPercentage(value) {
 function bytesPercentage(bytes) {
     return bytes.total > 0 ? percentage((bytes.downloaded / bytes.total) * 100) : 0;
 }
-function record(value) {
-    return typeof value === 'object' && value !== null;
-}
 function uint(value) {
     return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
 }

package/dist-lib/lib/models/context.d.ts

@@ -2,4 +2,4 @@ import type { ModelRegistryEntry } from '@qvac/sdk';
 export type ModelSrc = string | (ModelRegistryEntry & {
     src: string;
 });
-export declare function defaultContextSize(modelSrc: ModelSrc): number;
+export declare function defaultContextSize(modelSrc: ModelSrc, trainedContext?: number): number;

package/dist-lib/lib/models/context.js

@@ -1,7 +1,11 @@
 const TINY_MODEL_PARAMS_BILLIONS = 0.8;
 const TINY_MODEL_CONTEXT_SIZE = 8_192;
 const DESKTOP_DEFAULT_CONTEXT_SIZE = 51_200;
-export function defaultContextSize(modelSrc) {
+export function defaultContextSize(modelSrc, trainedContext) {
+    const size = tieredContextSize(modelSrc);
+    return trainedContext ? Math.min(size, trainedContext) : size;
+}
+function tieredContextSize(modelSrc) {
     if (typeof modelSrc === 'string')
         return DESKTOP_DEFAULT_CONTEXT_SIZE;
     const params = Number.parseFloat(modelSrc.params);

package/dist-lib/lib/models/custom-model-cache.d.ts

@@ -1,4 +1,13 @@
 import type { CustomModelEntry } from './model-catalog.ts';
+export interface CustomDownloads {
+    readonly files: ReadonlyArray<string>;
+    readonly dirs: ReadonlyArray<string>;
+}
 export declare function customFileCachePath(src: string, modelsDir: string | undefined): string | null;
-export declare function downloadedCustomFiles(entry: CustomModelEntry, modelsDir: string | undefined): string[];
+export interface CustomShardCache {
+    readonly dir: string;
+    readonly files: ReadonlyArray<string>;
+}
+export declare function customShardCache(src: string, modelsDir: string | undefined): CustomShardCache | null;
+export declare function customDownloads(entry: CustomModelEntry, modelsDir: string | undefined): Promise<CustomDownloads>;
 export declare function isCustomModelCached(entry: CustomModelEntry, modelsDir: string | undefined): Promise<boolean>;

package/dist-lib/lib/models/custom-model-cache.js

@@ -2,33 +2,61 @@ import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { isRemoteSource, localSourcePath } from './gguf-header.js';
-const SHARD = /-\d{5}-of-\d{5}\.\w+$/;
+import { shardSet } from './shards.js';
 const ARCHIVE = /\.(tar|tgz|zip)(\.\w+)?$/i;
 export function customFileCachePath(src, modelsDir) {
-    if (!isRemoteSource(src))
+    if (!isRemoteSource(src)) {
         return localSourcePath(src);
-    const filename = src.split('/').pop()?.split('?')[0] || 'model.gguf';
-    if (!modelsDir || SHARD.test(filename) || ARCHIVE.test(filename))
+    }
+    const filename = filenameOf(src);
+    if (!modelsDir || shardSet(src) || ARCHIVE.test(filename)) {
         return null;
-    const hash = crypto.createHash('sha256').update(src, 'utf8').digest('hex').slice(0, 16);
-    return path.join(modelsDir, `${hash}_${filename}`);
+    }
+    return path.join(modelsDir, `${shortHash(src)}_${filename}`);
 }
-export function downloadedCustomFiles(entry, modelsDir) {
-    const srcs = entry.projectionSrc ? [entry.src, entry.projectionSrc] : [entry.src];
-    return srcs
-        .filter(isRemoteSource)
-        .map((src) => customFileCachePath(src, modelsDir))
-        .filter((file) => file !== null);
+export function customShardCache(src, modelsDir) {
+    const set = shardSet(src);
+    if (!modelsDir || !isRemoteSource(src) || !set) {
+        return null;
+    }
+    const dir = path.join(modelsDir, 'sharded', shortHash(`${set.baseUrl}/${set.base}`));
+    return { dir, files: set.shards.map((shard) => path.join(dir, shard.filename)) };
+}
+export async function customDownloads(entry, modelsDir) {
+    const remote = sourcesOf(entry).filter(isRemoteSource);
+    const shardDirs = remote.flatMap((src) => customShardCache(src, modelsDir)?.dir ?? []);
+    const inShardDirs = await Promise.all(shardDirs.map(listFiles));
+    const singles = remote.flatMap((src) => customFileCachePath(src, modelsDir) ?? []);
+    return { files: [...singles, ...inShardDirs.flat()], dirs: shardDirs };
 }
 export async function isCustomModelCached(entry, modelsDir) {
-    const srcs = entry.projectionSrc ? [entry.src, entry.projectionSrc] : [entry.src];
-    const sizes = await Promise.all(srcs.map((src) => onDiskSize(customFileCachePath(src, modelsDir))));
+    const expected = sourcesOf(entry).flatMap((src) => customShardCache(src, modelsDir)?.files ?? [customFileCachePath(src, modelsDir)]);
+    const sizes = await Promise.all(expected.map(onDiskSize));
     const present = sizes.filter((size) => size !== null);
-    if (present.length < sizes.length)
+    if (present.length < sizes.length) {
         return false;
+    }
     const total = present.reduce((sum, size) => sum + size, 0);
     return entry.expectedSize ? total === entry.expectedSize : true;
 }
+function sourcesOf(entry) {
+    return entry.projectionSrc ? [entry.src, entry.projectionSrc] : [entry.src];
+}
+function filenameOf(src) {
+    return src.split('/').pop()?.split('?')[0] || 'model.gguf';
+}
+function shortHash(input) {
+    return crypto.createHash('sha256').update(input, 'utf8').digest('hex').slice(0, 16);
+}
+async function listFiles(dir) {
+    try {
+        const names = await fs.promises.readdir(dir);
+        return names.map((name) => path.join(dir, String(name)));
+    }
+    catch {
+        return [];
+    }
+}
 async function onDiskSize(file) {
     if (file === null)
         return null;

package/dist-lib/lib/models/gguf-header.d.ts

@@ -23,8 +23,9 @@ export declare const GGUF_HEADER_BYTES = 1048576;
 export declare const GGUF_HEADER_TIMEOUT_MS = 30000;
 export declare function isRemoteSource(src: string): boolean;
 export declare function localSourcePath(src: string): string | null;
-export declare function readGgufHeaderBytes(src: string, opts?: {
+export interface ReadGgufHeaderOptions {
     fetch?: GgufRangeFetch;
     maxBytes?: number;
-}): Promise<Uint8Array | null>;
+}
+export declare function readGgufHeaderBytes(src: string, opts?: ReadGgufHeaderOptions): Promise<Uint8Array | null>;
 export declare function parseGgufHeader(bytes: Uint8Array): GgufHeader | null;

package/dist-lib/lib/models/gguf-header.js

@@ -5,6 +5,7 @@ import os from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import defaultFetch from '#fetch';
+const rangeFetch = defaultFetch;
 export const GGUF_HEADER_BYTES = 1_048_576;
 export const GGUF_HEADER_TIMEOUT_MS = 30_000;
 const UINT8 = 0;
@@ -24,14 +25,17 @@ export function isRemoteSource(src) {
     return /^https?:\/\//i.test(src);
 }
 export function localSourcePath(src) {
-    if (/^file:/i.test(src))
+    if (/^file:/i.test(src)) {
         return filePath(src);
+    }
     if (/^[a-z][a-z0-9+.-]+:/i.test(src))
         return null;
-    if (src === '~')
+    if (src === '~') {
         return os.homedir();
-    if (src.startsWith('~/'))
+    }
+    if (src.startsWith('~/')) {
         return path.join(os.homedir(), src.slice(2));
+    }
     return src;
 }
 function filePath(src) {
@@ -45,7 +49,7 @@ function filePath(src) {
 export function readGgufHeaderBytes(src, opts = {}) {
     const maxBytes = opts.maxBytes ?? GGUF_HEADER_BYTES;
     return isRemoteSource(src)
-        ? fetchHead(src, maxBytes, opts.fetch ?? defaultFetch)
+        ? fetchHead(src, maxBytes, opts.fetch ?? rangeFetch)
         : readLocalHead(src, maxBytes);
 }
 async function fetchHead(src, maxBytes, fetch) {
@@ -56,11 +60,13 @@ async function fetchHead(src, maxBytes, fetch) {
             headers: { Range: `bytes=0-${maxBytes - 1}` },
             signal: controller.signal
         });
-        if (!response.ok)
+        if (!response.ok) {
             return null;
+        }
         const length = response.headers.get('content-length');
-        if (length === null || !(Number(length) <= maxBytes))
+        if (length === null || !(Number(length) <= maxBytes)) {
             return null;
+        }
         return new Uint8Array(await response.arrayBuffer()).subarray(0, maxBytes);
     }
     catch {
@@ -72,8 +78,9 @@ async function fetchHead(src, maxBytes, fetch) {
 }
 async function readLocalHead(src, maxBytes) {
     const file = localSourcePath(src);
-    if (file === null)
+    if (file === null) {
         return null;
+    }
     let handle;
     try {
         handle = await fs.promises.open(file, 'r');
@@ -98,32 +105,42 @@ export function parseGgufHeader(bytes) {
         bytes,
         offset: 16
     };
-    if (c.view.getUint32(4, true) < 2)
+    if (c.view.getUint32(4, true) < 2) {
         return null;
+    }
     const count = readU64(c);
     const header = {};
     const contextLengths = new Map();
     for (let i = 0; i < count; i += 1) {
         const key = readString(c);
-        if (key === null || !has(c, 4))
+        if (key === null || !has(c, 4)) {
             break;
+        }
         const value = readValue(c, readU32(c), key === 'general.tags');
-        if (!value.ok)
+        if (!value.ok) {
             break;
-        if (key === 'general.architecture')
+        }
+        if (key === 'general.architecture') {
             header.architecture = value.str;
-        else if (key === 'general.name')
+        }
+        else if (key === 'general.name') {
             header.name = value.str;
-        else if (key === 'general.type')
+        }
+        else if (key === 'general.type') {
             header.type = value.str;
-        else if (key === 'general.license')
+        }
+        else if (key === 'general.license') {
             header.license = value.str;
-        else if (key === 'general.size_label')
+        }
+        else if (key === 'general.size_label') {
             header.sizeLabel = value.str;
-        else if (key === 'general.tags')
+        }
+        else if (key === 'general.tags') {
             header.tags = value.strs;
-        else if (key.endsWith('.context_length'))
+        }
+        else if (key.endsWith('.context_length')) {
             contextLengths.set(key, value.num);
+        }
     }
     header.contextLength =
         contextLengths.get(`${header.architecture}.context_length`) ??
@@ -157,17 +174,20 @@ function readValue(c, type, collect = false) {
             return str === null ? { ok: false } : { ok: true, str };
         }
         case ARRAY: {
-            if (!has(c, 12))
+            if (!has(c, 12)) {
                 return { ok: false };
+            }
             const elementType = readU32(c);
             const length = readU64(c);
             const strs = new Array();
             for (let i = 0; i < length; i += 1) {
                 const element = readValue(c, elementType);
-                if (!element.ok)
+                if (!element.ok) {
                     return { ok: false };
-                if (collect && element.str !== undefined)
+                }
+                if (collect && element.str !== undefined) {
                     strs.push(element.str);
+                }
             }
             return collect ? { ok: true, strs } : { ok: true };
         }
@@ -176,8 +196,9 @@ function readValue(c, type, collect = false) {
     }
 }
 function fixed(c, width, read) {
-    if (!has(c, width))
+    if (!has(c, width)) {
         return { ok: false };
+    }
     const num = read();
     c.offset += width;
     return { ok: true, num };
@@ -200,8 +221,9 @@ function readString(c) {
     if (!has(c, 8))
         return null;
     const length = readU64(c);
-    if (!has(c, length))
+    if (!has(c, length)) {
         return null;
+    }
     const str = b4a.toString(c.bytes.subarray(c.offset, c.offset + length), 'utf8');
     c.offset += length;
     return str;

package/dist-lib/lib/models/idle-unload.d.ts

@@ -0,0 +1,14 @@
+export interface IdleReaperOptions {
+    sweep: () => Promise<void>;
+    waitMs: number;
+    onError: (err: unknown) => void;
+    now?: () => number;
+    tickMs?: number;
+}
+export interface IdleReaper {
+    configure(timeoutMs: number): void;
+    enter(): Promise<void>;
+    exit(): void;
+    close(): void;
+}
+export declare function createIdleReaper({ sweep, waitMs, onError, now, tickMs }: IdleReaperOptions): IdleReaper;

package/dist-lib/lib/models/idle-unload.js

@@ -0,0 +1,51 @@
+import { raceTimeout } from '../helpers/race-timeout.js';
+const DEFAULT_TICK_MS = 60_000;
+export function createIdleReaper({ sweep, waitMs, onError, now = Date.now, tickMs = DEFAULT_TICK_MS }) {
+    let timeoutMs = 0;
+    let inflight = 0;
+    let lastActivity = now();
+    let sweeping = null;
+    let timer = null;
+    const tick = () => {
+        if (sweeping !== null || inflight > 0 || now() - lastActivity < timeoutMs) {
+            return;
+        }
+        const run = sweep().catch(onError).catch(noop);
+        sweeping = raceTimeout(run, { ms: waitMs, fallback: undefined }).finally(() => {
+            sweeping = null;
+            lastActivity = now();
+        });
+    };
+    const disarm = () => {
+        if (timer !== null) {
+            clearInterval(timer);
+        }
+        timer = null;
+    };
+    return {
+        configure(ms) {
+            timeoutMs = ms;
+            disarm();
+            if (ms <= 0) {
+                return;
+            }
+            timer = setInterval(tick, Math.min(tickMs, ms));
+            if (typeof timer.unref === 'function') {
+                timer.unref();
+            }
+        },
+        async enter() {
+            inflight++;
+            lastActivity = now();
+            if (sweeping !== null) {
+                await sweeping;
+            }
+        },
+        exit() {
+            inflight--;
+            lastActivity = now();
+        },
+        close: disarm
+    };
+}
+function noop() { }

package/dist-lib/lib/models/kv-cache.d.ts

@@ -1,4 +1,5 @@
-export declare function adrenoSafeKvCache(device: 'cpu' | 'gpu' | undefined, requestedK: string | undefined, requestedV: string | undefined, hostPlatform?: string): {
+export interface KvCacheTypes {
     k: string | undefined;
     v: string | undefined;
-};
+}
+export declare function adrenoSafeKvCache(device: 'cpu' | 'gpu' | undefined, { k, v }: KvCacheTypes, hostPlatform?: string): KvCacheTypes;

package/dist-lib/lib/models/kv-cache.js

@@ -1,6 +1,7 @@
 import { platform } from 'os';
-export function adrenoSafeKvCache(device, requestedK, requestedV, hostPlatform = platform()) {
-    if (device === 'cpu' || hostPlatform !== 'android')
-        return { k: requestedK, v: requestedV };
+export function adrenoSafeKvCache(device, { k, v }, hostPlatform = platform()) {
+    if (device === 'cpu' || hostPlatform !== 'android') {
+        return { k, v };
+    }
     return { k: 'f16', v: 'f16' };
 }