@qvac/harness 0.1.2 → 0.2.1

package/dist/prebuilds-manifest.json

@@ -1,12 +1,5 @@
 {
   "packages": {
-    "@qvac/audiogen-ggml": [
-      "darwin-arm64",
-      "darwin-x64",
-      "linux-arm64",
-      "linux-x64",
-      "win32-x64"
-    ],
     "bare-abort": [
       "darwin-arm64",
       "darwin-x64",

package/dist-lib/index.d.ts

@@ -224,6 +224,7 @@ export declare class Harness extends ReadyResource {
     list(options?: ListModelsOptions): Promise<ModelInfo[]>;
     deleteModel(name: string): Promise<DeleteModelSummary>;
     clearKvCache(): Promise<KvCacheDeletionResult>;
+    deleteKvCache(kvCacheKey: string): Promise<KvCacheDeletionResult>;
     infraModels(profile: string): Promise<Array<{
         name: string;
         addon: string;

package/dist-lib/index.js

@@ -8,7 +8,7 @@ import { closePythonWorker } from "./lib/tools/exec/adapters/python/worker/clien
 import { completion } from "./lib/capabilities/completion.js";
 import { download } from "./lib/capabilities/download.js";
 import { createEmbedLane } from "./lib/capabilities/embed.js";
-import { deleteAllKvCaches } from "./lib/capabilities/kv-cache.js";
+import { deleteAllKvCaches, deleteKvCacheKey } from "./lib/capabilities/kv-cache.js";
 import { pcmForTranscription } from "./lib/capabilities/audio-resample.js";
 import { buildWavBuffer } from "./lib/wav-encode.js";
 import { createVoiceLane, packSamples, speakOnce, speakStreamOnce, transcribeOnce, transcribeStreaming, SUPERTONIC_SAMPLE_RATE } from "./lib/capabilities/voice.js";
@@ -137,6 +137,7 @@ export class Harness extends ReadyResource {
             device: embedConfig.device,
             gpuLayers: embedConfig.gpuLayers
         });
+        const imageTransfers = new Map();
         const image = typeof imageModel === 'string' ? { model: imageModel } : imageModel;
         this._imageRuntime = image
             ? createDiffusionRuntime({
@@ -145,10 +146,22 @@ export class Harness extends ReadyResource {
                 loadSdk: () => this._loadDiffusionSdk(),
                 onProgress: (model, progress) => {
                     const state = progressState(model, progress);
-                    if (state.status === 'loading' && state.percentage === 100) {
-                        invalidateModelStatusCache(this._modelStatus);
+                    if (state.status === 'downloading' &&
+                        typeof progress.percentage === 'number' &&
+                        progress.percentage < 100) {
+                        imageTransfers.set(model, state);
                     }
-                    this.emit('model', state);
+                    this.emit('model', state.status === 'downloading' && !imageTransfers.has(model)
+                        ? { ...state, status: 'loading' }
+                        : state);
+                },
+                onLoaded: (model) => {
+                    const transfer = imageTransfers.get(model);
+                    if (!transfer)
+                        return;
+                    imageTransfers.delete(model);
+                    invalidateModelStatusCache(this._modelStatus);
+                    this.emit('model', { ...transfer, status: 'downloaded' });
                 },
                 onBeforeLoad: async (signal) => {
                     if (this._models.destroyed)
@@ -852,6 +865,10 @@ export class Harness extends ReadyResource {
         await this.ready();
         return deleteAllKvCaches(() => this._sdk.load());
     }
+    async deleteKvCache(kvCacheKey) {
+        await this.ready();
+        return deleteKvCacheKey(() => this._sdk.load(), kvCacheKey);
+    }
     async infraModels(profile) {
         return infraModelsFor(profile);
     }

package/dist-lib/lib/audio-transcode-bare.js

@@ -32,11 +32,11 @@ function bufferReadIO(input) {
         }
     });
 }
-function makeOutFrame(capacity) {
+function makeOutFrame(capacity, rate) {
     const out = new ffmpeg.Frame();
     out.format = ffmpeg.constants.sampleFormats.S16;
     out.channelLayout = ffmpeg.constants.channelLayouts.MONO;
-    out.sampleRate = TARGET_SAMPLE_RATE;
+    out.sampleRate = rate;
     out.nbSamples = capacity;
     out.alloc();
     return out;
@@ -47,23 +47,23 @@ function readChunk(samples, outFrame, produced) {
     samples.read(outFrame);
     return Buffer.from(samples.data.subarray(0, produced * 2));
 }
-function createResampler(frame) {
-    return new ffmpeg.Resampler(frame.sampleRate, frame.channelLayout, frame.format, TARGET_SAMPLE_RATE, ffmpeg.constants.channelLayouts.MONO, ffmpeg.constants.sampleFormats.S16);
+function createResampler(frame, rate) {
+    return new ffmpeg.Resampler(frame.sampleRate, frame.channelLayout, frame.format, rate, ffmpeg.constants.channelLayouts.MONO, ffmpeg.constants.sampleFormats.S16);
 }
-function convertFrame(resampler, frame, samples) {
-    const capacity = Math.ceil((frame.nbSamples * TARGET_SAMPLE_RATE) / frame.sampleRate) + 1024;
-    const outFrame = makeOutFrame(capacity);
+function convertFrame(resampler, frame, samples, rate) {
+    const capacity = Math.ceil((frame.nbSamples * rate) / frame.sampleRate) + 1024;
+    const outFrame = makeOutFrame(capacity, rate);
     const chunk = readChunk(samples, outFrame, resampler.convert(frame, outFrame));
     outFrame.destroy();
     return chunk;
 }
-function flushResampler(resampler, samples) {
+function flushResampler(resampler, samples, rate) {
     if (!resampler)
         return [];
     const chunks = [];
     let flushed = 0;
     do {
-        const outFrame = makeOutFrame(TARGET_SAMPLE_RATE);
+        const outFrame = makeOutFrame(rate, rate);
         flushed = resampler.flush(outFrame);
         const chunk = readChunk(samples, outFrame, flushed);
         if (chunk)
@@ -72,11 +72,11 @@ function flushResampler(resampler, samples) {
     } while (flushed > 0);
     return chunks;
 }
-function drainDecodedFrames(decoder, frame, samples, resampler, chunks) {
+function drainDecodedFrames(decoder, frame, samples, resampler, chunks, rate) {
     let current = resampler;
     while (decoder.receiveFrame(frame)) {
-        current ??= createResampler(frame);
-        const chunk = convertFrame(current, frame, samples);
+        current ??= createResampler(frame, rate);
+        const chunk = convertFrame(current, frame, samples, rate);
         if (chunk)
             chunks.push(chunk);
     }
@@ -86,7 +86,7 @@ const YIELD_EVERY_PACKETS = 32;
 function yieldToLoop() {
     return new Promise((resolve) => setTimeout(resolve, 0));
 }
-async function decodeToPcmChunks(inputFormat, stream, decoder) {
+async function decodeToPcmChunks(inputFormat, stream, decoder, rate) {
     const chunks = [];
     const packet = new ffmpeg.Packet();
     const flush = new ffmpeg.Packet();
@@ -97,15 +97,15 @@ async function decodeToPcmChunks(inputFormat, stream, decoder) {
     try {
         while (inputFormat.readFrame(packet)) {
             if (packet.streamIndex === stream.index && decoder.sendPacket(packet)) {
-                resampler = drainDecodedFrames(decoder, frame, samples, resampler, chunks);
+                resampler = drainDecodedFrames(decoder, frame, samples, resampler, chunks, rate);
             }
             packet.unref();
             if (++packets % YIELD_EVERY_PACKETS === 0)
                 await yieldToLoop();
         }
         decoder.sendPacket(flush);
-        resampler = drainDecodedFrames(decoder, frame, samples, resampler, chunks);
-        chunks.push(...flushResampler(resampler, samples));
+        resampler = drainDecodedFrames(decoder, frame, samples, resampler, chunks, rate);
+        chunks.push(...flushResampler(resampler, samples, rate));
     }
     finally {
         resampler?.destroy();
@@ -115,7 +115,7 @@ async function decodeToPcmChunks(inputFormat, stream, decoder) {
     }
     return chunks;
 }
-async function decodeInputToPcm(input) {
+async function decodeInputToPcm(input, rate) {
     let inputFormat = null;
     let decoder = null;
     try {
@@ -123,7 +123,7 @@ async function decodeInputToPcm(input) {
         const stream = inputFormat.getBestStream(ffmpeg.constants.mediaTypes.AUDIO);
         decoder = stream.decoder();
         decoder.open();
-        const chunks = await decodeToPcmChunks(inputFormat, stream, decoder);
+        const chunks = await decodeToPcmChunks(inputFormat, stream, decoder, rate);
         return chunks.length === 0 ? null : Buffer.concat(chunks);
     }
     catch (e) {
@@ -137,9 +137,9 @@ async function decodeInputToPcm(input) {
     }
 }
 export async function transcodeToWav16kMono(input) {
-    const pcm = await decodeInputToPcm(input);
+    const pcm = await decodeInputToPcm(input, TARGET_SAMPLE_RATE);
     return pcm ? buildWavBuffer(pcm) : null;
 }
 export async function transcodeToPcm16kMono(input) {
-    return decodeInputToPcm(input);
+    return decodeInputToPcm(input, TARGET_SAMPLE_RATE);
 }

package/dist-lib/lib/capabilities/completion.d.ts

@@ -159,10 +159,15 @@ export interface ToolParameters {
     properties: Record<string, ToolParameterSchema>;
     required?: string[];
 }
+export interface ToolPromptDefinition {
+    description?: string;
+    parameters?: ToolParameters;
+}
 export interface ToolDefinition {
     name: string;
     description: string;
     parameters: ToolParameters;
+    prompt?: ToolPromptDefinition;
     autoApprove?: boolean;
     skillGated?: boolean;
     rootsRequired?: boolean;
@@ -279,6 +284,7 @@ interface CompletionArgs {
     fsRoots?: readonly DriveRoot[];
     fsWriteRoots?: readonly DriveRoot[];
 }
+export declare const CONTEXT_OVERFLOW_MESSAGE = "This message is too large for the model context window.";
 export declare function trustedSourcesFrom(history: readonly Message[]): TrustedSource[];
 export declare function toSdkTool(tool: ToolDefinition): SdkTool;
 export type CompletionSkillEntry = SkillCatalogEntry & {

package/dist-lib/lib/capabilities/completion.js

@@ -26,6 +26,7 @@ import { isAvailableState } from "../tools/skills/skill-state-constants.js";
 import { resolveImplicitSkill, resolveSkillMention, skillPreloadMessage } from "../tools/skills/mention.js";
 import { permittedTools } from "../tools/toolsets.js";
 import { promptPrefixHash } from "./prompt-prefix.js";
+import { logToolPrompt } from "./tool-prompt-log.js";
 import { DIRECT_CALL_ID, loadedSkillFilesFrom, loadedSkillsFrom, TOOL_CONTINUATION_NUDGE, toolResultTurn, withoutSkillLoadTurns } from "./tool-turns.js";
 import { projectVisionHistory, visionHistoryCacheKey } from "./vision-history.js";
 export function imageSettingsFrom(agent) {
@@ -49,7 +50,7 @@ function runWallClockBudgetMs() {
     const ms = Number(process.env.QVAC_RUN_BUDGET_MS);
     return ms > 0 ? ms : RUN_WALL_CLOCK_BUDGET_MS;
 }
-const CONTEXT_OVERFLOW_MESSAGE = 'This message is too large for the model context window.';
+export const CONTEXT_OVERFLOW_MESSAGE = 'This message is too large for the model context window.';
 const MAX_MUTE_ROUNDS = 1;
 const NARRATED_INTENT = /\b(I['’]ll|I will|Now I|Let me(?! know)|Next,? I)\b[^.!?]*[.!?]?\s*$/i;
 const MAX_WEB_SEARCHES_PER_TURN = 3;
@@ -72,25 +73,25 @@ function originOfToolTurn(text) {
     return text.startsWith(`[Tool: ${SKILL_TOOL_NAME} (`) ? 'skill' : 'tool-result';
 }
 const noop = () => { };
-function intentParameters(tool) {
-    if (tool.autoApprove === true || INTENT_PARAM in tool.parameters.properties) {
-        return tool.parameters;
+function intentParameters(tool, params) {
+    if (tool.autoApprove === true || INTENT_PARAM in params.properties) {
+        return params;
     }
     return {
-        ...tool.parameters,
+        ...params,
         properties: {
             [INTENT_PARAM]: { type: 'string', description: INTENT_PARAM_DESCRIPTION },
-            ...tool.parameters.properties
+            ...params.properties
         },
-        required: [INTENT_PARAM, ...(tool.parameters.required ?? [])]
+        required: [INTENT_PARAM, ...(params.required ?? [])]
     };
 }
 export function toSdkTool(tool) {
     return {
         type: 'function',
         name: tool.name,
-        description: tool.description,
-        parameters: intentParameters(tool)
+        description: tool.prompt?.description ?? tool.description,
+        parameters: intentParameters(tool, tool.prompt?.parameters ?? tool.parameters)
     };
 }
 function sanitizeTurn(turn) {
@@ -597,18 +598,21 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         };
         const activeSkills = inContextSkills.filter((skill) => skillIsActive(skill.name, activation));
         const { grantedNames, grantedOwners, grantedOps } = collectToolGrants(activeSkills);
-        const enabled = responseFormat
-            ? []
-            : enabledTools(tools, {
+        function selectEnabled() {
+            if (responseFormat)
+                return [];
+            const loaded = activeSkills.filter((skill) => loadedSkills.has(skill.name));
+            return enabledTools(tools, {
                 toolsSelected,
                 allowlist: agent?.enabledTools ?? [],
                 grantedNames,
                 grantedOwners,
+                loadedGrantedNames: collectToolGrants(loaded).grantedNames,
                 hasRoots: fsRoots.length > 0,
                 hasWriteRoots: writableRoots.length > 0,
                 hasActiveSkills: activeSkills.length > 0
             });
-        const sdkTools = enabled.length ? enabled.map((tool) => toSdkTool(tool)) : undefined;
+        }
         const reasoningEnabled = agent?.reasoning === 'enabled' ? true : agent?.reasoning === 'disabled' ? false : undefined;
         const deviceReasoning = thinkingDefault === 'enabled' ? true : thinkingDefault === 'disabled' ? false : undefined;
         const resolvedGenerationParams = resolveLlmGenerationParams(model, reasoningEnabled, deviceReasoning);
@@ -672,14 +676,35 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             loadedThisTurn.add(preload.name);
             skillIcon = skillEmoji(preload.name) ?? skillIcon;
         }
+        let enabled = selectEnabled();
+        let sdkTools = enabled.length ? enabled.map((tool) => toSdkTool(tool)) : undefined;
         const system = systemPromptParts({
             bio: agent?.bio,
             toolNames: enabled.map((tool) => tool.name),
             skillsSection: skillsPromptSection(activeSkills)
         });
         const systemContent = system.text;
-        const promptPrefix = promptPrefixHash({ system: systemContent, tools: sdkTools });
-        const promptParts = promptUsageParts({ system, toolSchemas: sdkTools });
+        let promptPrefix = promptPrefixHash({ system: systemContent, tools: sdkTools });
+        let promptParts = promptUsageParts({ system, toolSchemas: sdkTools });
+        function logSelection() {
+            logToolPrompt({
+                promptPrefix,
+                modelId,
+                cacheKey,
+                agentId: agent?.id,
+                messageCount: messages.length,
+                responseFormat: responseFormat?.type,
+                tools: sdkTools,
+                definitions: enabled,
+                activeSkills: activeSkills.map((skill) => skill.name),
+                skillsSelected,
+                enabledSkills: agent?.enabledSkills ?? [],
+                mentionedSkill: mention?.name ?? null,
+                loadedSkills,
+                toolOps: grantedOps
+            });
+        }
+        logSelection();
         let history = annotateLastUserTime(systemContent ? [{ role: 'system', content: systemContent }, ...turns] : turns);
         let roundCacheKey = stubDropped ? undefined : visionHistoryCacheKey(cacheKey, history);
         const runUsage = () => usageBreakdown(promptParts, stats.cacheTokens, model);
@@ -771,6 +796,14 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 outcome = 'time-capped';
                 break;
             }
+            const reselected = selectEnabled();
+            if (reselected.map((tool) => tool.name).join() !== enabled.map((tool) => tool.name).join()) {
+                enabled = reselected;
+                sdkTools = enabled.length ? enabled.map((tool) => toSdkTool(tool)) : undefined;
+                promptPrefix = promptPrefixHash({ system: systemContent, tools: sdkTools });
+                promptParts = promptUsageParts({ system, toolSchemas: sdkTools });
+                logSelection();
+            }
             hlog('round start', {
                 round,
                 turns: history.length,

package/dist-lib/lib/capabilities/download.d.ts

@@ -5,10 +5,12 @@ import { type ModelAddon, type ModelRegistrySdk } from '../models/model-source.t
 export type DownloadProgress = Omit<ModelProgressUpdate, 'type'>;
 export type DownloadProgressEvent = {
     type: 'progress';
+    transferred?: boolean;
 } & DownloadProgress;
 export type DownloadCompleteEvent = {
     type: 'complete';
     assetId: string;
+    downloaded?: boolean;
 };
 export type DownloadErrorEvent = {
     type: 'error';

package/dist-lib/lib/capabilities/download.js

@@ -5,6 +5,7 @@ const noop = () => { };
 export function download(sdkOrLoader, args, onSettled) {
     const { model, addon = 'llm', seed, signal, projection, companions = [], assetSizes } = args;
     const loadSdk = typeof sdkOrLoader === 'function' ? sdkOrLoader : () => Promise.resolve(sdkOrLoader);
+    let transferred = false;
     let settled = false;
     let opDone = false;
     let cancelSent = false;
@@ -30,7 +31,7 @@ export function download(sdkOrLoader, args, onSettled) {
     };
     const onProgress = (p) => {
         if (!settled)
-            stream.push({ ...p, type: 'progress' });
+            stream.push({ ...p, type: 'progress', transferred });
     };
     const start = async () => {
         if (signal?.aborted)
@@ -56,14 +57,22 @@ export function download(sdkOrLoader, args, onSettled) {
                         totalBytes: aggregate.totalBytes
                     })
                     : onProgress;
-                const op = sdkRef.downloadAsset({ assetSrc: srcs[i], seed, onProgress: progress });
+                const op = sdkRef.downloadAsset({
+                    assetSrc: srcs[i],
+                    seed,
+                    onProgress: (update) => {
+                        if (update.percentage < 100)
+                            transferred = true;
+                        progress(update);
+                    }
+                });
                 requestId = op.requestId;
                 const assetId = await op;
                 if (i === 0)
                     mainAssetId = assetId;
             }
             opDone = true;
-            finish({ type: 'complete', assetId: mainAssetId });
+            finish({ type: 'complete', assetId: mainAssetId, downloaded: transferred });
         }
         catch (err) {
             opDone = true;

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

@@ -9,5 +9,6 @@ export type KvCacheDeletionResult = {
 };
 type KvCacheSdk = Pick<typeof import('@qvac/sdk'), 'deleteCache'>;
 export declare function deleteAllKvCaches(loadSdk: () => Promise<KvCacheSdk>): Promise<KvCacheDeletionResult>;
+export declare function deleteKvCacheKey(loadSdk: () => Promise<KvCacheSdk>, kvCacheKey: string): Promise<KvCacheDeletionResult>;
 export declare function unsupportedKvCacheDeletion(error?: string): KvCacheDeletionResult;
 export {};

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

@@ -1,7 +1,13 @@
 export async function deleteAllKvCaches(loadSdk) {
+    return deleteCacheWith(loadSdk, { all: true });
+}
+export async function deleteKvCacheKey(loadSdk, kvCacheKey) {
+    return deleteCacheWith(loadSdk, { kvCacheKey });
+}
+async function deleteCacheWith(loadSdk, params) {
     try {
         const sdk = await loadSdk();
-        const result = await sdk.deleteCache({ all: true });
+        const result = await sdk.deleteCache(params);
         return result.success
             ? { status: 'success' }
             : { status: 'failure', error: 'SDK cache deletion did not succeed' };

package/dist-lib/lib/capabilities/tool-prompt-log.d.ts

@@ -0,0 +1,23 @@
+import type { Tool as SdkTool } from '@qvac/sdk';
+export interface ToolOwnership {
+    readonly name: string;
+    readonly skillGated?: boolean | undefined;
+    readonly owningSkill?: string | undefined;
+}
+export interface ToolPromptLogOptions {
+    readonly promptPrefix: string;
+    readonly modelId: string;
+    readonly cacheKey: string | undefined;
+    readonly agentId: string | undefined;
+    readonly messageCount: number;
+    readonly responseFormat: string | undefined;
+    readonly tools: ReadonlyArray<SdkTool> | undefined;
+    readonly definitions: ReadonlyArray<ToolOwnership>;
+    readonly activeSkills: ReadonlyArray<string>;
+    readonly skillsSelected: boolean;
+    readonly enabledSkills: ReadonlyArray<string>;
+    readonly mentionedSkill: string | null;
+    readonly loadedSkills: ReadonlySet<string>;
+    readonly toolOps: ReadonlyMap<string, ReadonlyArray<unknown>>;
+}
+export declare function logToolPrompt({ promptPrefix, modelId, cacheKey, agentId, messageCount, responseFormat, tools, definitions, activeSkills, skillsSelected, enabledSkills, mentionedSkill, loadedSkills, toolOps }: ToolPromptLogOptions): void;

package/dist-lib/lib/capabilities/tool-prompt-log.js

@@ -0,0 +1,62 @@
+import { harnessLogEnabled, hlog } from "../log.js";
+export function logToolPrompt({ promptPrefix, modelId, cacheKey, agentId, messageCount, responseFormat, tools = [], definitions, activeSkills, skillsSelected, enabledSkills, mentionedSkill, loadedSkills, toolOps }) {
+    if (!harnessLogEnabled())
+        return;
+    hlog('sdk tool definitions', {
+        promptPrefix,
+        modelId,
+        cacheKey: cacheKey ?? null,
+        agentId: agentId ?? null,
+        messageCount,
+        responseFormat: responseFormat ?? 'text',
+        schemaChars: tools.length ? JSON.stringify(tools).length : 0,
+        tools: rankedTools(tools, definitions),
+        skillGatedChars: skillGatedChars(tools, definitions),
+        activeSkills,
+        skillActivation: {
+            scope: skillsSelected ? 'selected' : 'all',
+            enabled: enabledSkills,
+            mentioned: mentionedSkill,
+            loaded: [...loadedSkills]
+        },
+        localCliValidators: [...toolOps].map(([bin, validators]) => ({
+            bin,
+            count: validators.length
+        }))
+    });
+}
+function ownerOf(definitions, name) {
+    return definitions.find((definition) => definition.name === name);
+}
+function rankedTools(tools, definitions) {
+    return tools
+        .map((tool) => {
+        const owner = ownerOf(definitions, tool.name);
+        return {
+            name: tool.name,
+            schemaChars: JSON.stringify(tool).length,
+            descriptionChars: descriptionChars(tool),
+            parameters: Object.keys(tool.parameters.properties),
+            required: tool.parameters.required ?? [],
+            skillGated: owner?.skillGated === true,
+            owningSkill: owner?.owningSkill ?? null
+        };
+    })
+        .sort((a, b) => b.schemaChars - a.schemaChars);
+}
+function skillGatedChars(tools, definitions) {
+    let chars = 0;
+    for (const tool of tools) {
+        if (ownerOf(definitions, tool.name)?.skillGated !== true)
+            continue;
+        chars += JSON.stringify(tool).length;
+    }
+    return chars;
+}
+function descriptionChars(tool) {
+    let chars = tool.description.length;
+    for (const parameter of Object.values(tool.parameters.properties)) {
+        chars += parameter.description?.length ?? 0;
+    }
+    return chars;
+}

package/dist-lib/lib/capabilities/tool-selection.d.ts

@@ -35,9 +35,10 @@ export interface ToolGateInputs {
     allowlist: ReadonlyArray<string>;
     grantedNames: ReadonlySet<string>;
     grantedOwners: ReadonlyMap<string, ReadonlySet<string>>;
+    loadedGrantedNames: ReadonlySet<string>;
     hasRoots: boolean;
     hasWriteRoots: boolean;
     hasActiveSkills: boolean;
 }
 export declare function isSelected(scope: 'all' | 'selected' | null | undefined, list?: ReadonlyArray<string> | null): boolean;
-export declare function enabledTools<T extends SelectableTool>(tools: ReadonlyArray<T>, { toolsSelected, allowlist, grantedNames, grantedOwners, hasRoots, hasWriteRoots, hasActiveSkills }: ToolGateInputs): T[];
+export declare function enabledTools<T extends SelectableTool>(tools: ReadonlyArray<T>, { toolsSelected, allowlist, grantedNames, grantedOwners, loadedGrantedNames, hasRoots, hasWriteRoots, hasActiveSkills }: ToolGateInputs): T[];

package/dist-lib/lib/capabilities/tool-selection.js

@@ -35,7 +35,7 @@ export function skillIsActive(name, { skillsSelected, enabledSkills, mention, lo
 export function isSelected(scope, list) {
     return (scope ?? (list?.length ? 'selected' : 'all')) === 'selected';
 }
-export function enabledTools(tools, { toolsSelected, allowlist, grantedNames, grantedOwners, hasRoots, hasWriteRoots, hasActiveSkills }) {
+export function enabledTools(tools, { toolsSelected, allowlist, grantedNames, grantedOwners, loadedGrantedNames, hasRoots, hasWriteRoots, hasActiveSkills }) {
     return tools.filter((tool) => {
         if (tool.name === SKILL_TOOL_NAME)
             return hasActiveSkills;
@@ -52,7 +52,7 @@ export function enabledTools(tools, { toolsSelected, allowlist, grantedNames, gr
         if (tool.writeRootsRequired)
             return hasWriteRoots;
         if (tool.skillGated)
-            return grantedNames.has(tool.name);
+            return loadedGrantedNames.has(tool.name);
         if (!toolsSelected)
             return true;
         return allowlist.includes(tool.name) || grantedNames.has(tool.name);

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

@@ -65,6 +65,8 @@ export declare class RemoteHarness extends EventEmitter implements HarnessContra
     list(options?: ListModelsOptions): Promise<ModelInfo[]>;
     deleteModel(name: string): Promise<DeleteModelSummary>;
     clearKvCache(): Promise<KvCacheDeletionResult>;
+    deleteKvCache(kvCacheKey: string): Promise<KvCacheDeletionResult>;
+    private _deleteKvCaches;
     infraModels(profile: string): Promise<Array<{
         name: string;
         addon: string;

package/dist-lib/lib/connect.js

@@ -524,12 +524,18 @@ export class RemoteHarness extends EventEmitter {
         return { name: response.name, removed: response.removed, freedBytes: response.freedBytes };
     }
     async clearKvCache() {
+        return this._deleteKvCaches((client) => client.clearKvCache({}));
+    }
+    async deleteKvCache(kvCacheKey) {
+        return this._deleteKvCaches((client) => client.deleteKvCache({ kvCacheKey }));
+    }
+    async _deleteKvCaches(call) {
         try {
             const { client } = await this._ensure();
             const info = await client.describe({});
             if (info.supportsKvCacheDeletion !== true)
                 return unsupportedKvCacheDeletion();
-            const response = await client.clearKvCache({});
+            const response = await call(client);
             if (response.status === 'success')
                 return { status: 'success' };
             if (response.status === 'failure') {

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

@@ -191,6 +191,7 @@ export interface HarnessContract {
     warmModel?(context: WarmModelContext): Promise<void>;
     deleteModel?(name: string): Promise<DeleteModelSummary>;
     clearKvCache?(): Promise<KvCacheDeletionResult>;
+    deleteKvCache?(kvCacheKey: string): Promise<KvCacheDeletionResult>;
     infraModels?(profile: string): Promise<ReadonlyArray<{
         name: string;
         addon: string;

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

@@ -5,7 +5,7 @@ import { type ModelAddon } from './model-source.ts';
 import type { GpuFaultState } from './sdk-faults.ts';
 type SdkModule = typeof import('@qvac/sdk');
 export interface ModelState {
-    status: 'loading' | 'downloading' | 'ready' | 'unloading' | 'unloaded';
+    status: 'loading' | 'downloading' | 'downloaded' | 'ready' | 'unloading' | 'unloaded';
     model: string;
     [key: string]: unknown;
 }

package/dist-lib/lib/sdk-loader.d.ts

@@ -1,4 +1,4 @@
-type Sdk = typeof import('@qvac/sdk');
+type Sdk = typeof import('#sdk');
 export type SdkPlugin = Parameters<(typeof import('@qvac/sdk/plugins'))['registerPlugin']>[0];
 type Plugin = SdkPlugin;
 interface PluginRegistry {

package/dist-lib/lib/sdk-loader.js

@@ -1,7 +1,7 @@
 import { retryMemo } from "./helpers/retry-memo.js";
 import { hlog } from "./log.js";
 const defaultImports = {
-    sdk: () => import('@qvac/sdk'),
+    sdk: () => import('#sdk'),
     plugins: () => import('@qvac/sdk/plugins'),
     llm: () => import('@qvac/sdk/llamacpp-completion/plugin'),
     embeddings: () => import('@qvac/sdk/llamacpp-embedding/plugin'),

package/dist-lib/lib/serve.js

@@ -16,6 +16,7 @@ import { packVectors, toDownloadWire, toWire } from "./wire.js";
 const MODEL_STATUSES = new Set([
     'loading',
     'downloading',
+    'downloaded',
     'ready',
     'error',
     'unloading',
@@ -133,6 +134,7 @@ export function serveHarness(stream, harness) {
             return (await harness.deleteModel?.(name)) ?? { name, removed: 0, freedBytes: 0 };
         },
         clearKvCache: async () => (await harness.clearKvCache?.()) ?? unsupportedKvCacheDeletion(),
+        deleteKvCache: async ({ kvCacheKey }) => (await harness.deleteKvCache?.(kvCacheKey)) ?? unsupportedKvCacheDeletion(),
         infraModels: async ({ profile }) => ({
             models: (await harness.infraModels?.(profile ?? '')) ?? []
         }),