@qvac/harness 0.4.0 → 0.6.0

package/dist-lib/lib/web-search/fetch-html.js

@@ -37,7 +37,8 @@ function buildInit(options, signal) {
     }
     return init;
 }
-async function fetchWithTimeout(fetcher, url, options, callerSignal) {
+async function fetchWithTimeout(fetcher, url, options) {
+    const callerSignal = options?.signal;
     if (callerSignal?.aborted) {
         throw new AbortError();
     }
@@ -57,10 +58,12 @@ async function fetchWithTimeout(fetcher, url, options, callerSignal) {
         return { ok: resp.ok, status: resp.status, text };
     }
     catch (err) {
-        if (timedOut)
+        if (timedOut) {
             throw new TimeoutError(timeoutMs);
-        if (callerSignal?.aborted)
+        }
+        if (callerSignal?.aborted) {
             throw new AbortError();
+        }
         throw err;
     }
     finally {
@@ -68,8 +71,8 @@ async function fetchWithTimeout(fetcher, url, options, callerSignal) {
         callerSignal?.removeEventListener('abort', onCallerAbort);
     }
 }
-export async function fetchHtml(fetcher, url, options, signal) {
-    const { ok, status, text } = await fetchWithTimeout(fetcher, url, options, signal);
+export async function fetchHtml(fetcher, url, options) {
+    const { ok, status, text } = await fetchWithTimeout(fetcher, url, options);
     if (!ok) {
         throw new Error(`HTTP ${status}`);
     }
@@ -83,8 +86,11 @@ export class JsonParseError extends Error {
         this.name = 'JsonParseError';
     }
 }
-export async function fetchJson(fetcher, url, options, signal) {
-    const { ok, status, text } = await fetchWithTimeout(fetcher, url, { ...options, accept: options?.accept ?? 'application/json' }, signal);
+export async function fetchJson(fetcher, url, options) {
+    const { ok, status, text } = await fetchWithTimeout(fetcher, url, {
+        ...options,
+        accept: options?.accept ?? 'application/json'
+    });
     if (!ok) {
         throw new Error(`HTTP ${status}`);
     }

package/dist-lib/lib/web-search/orchestrator.d.ts

@@ -1,14 +1,18 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { Fetcher, WebSearchResult } from './types.ts';
-export type EngineSummaryEntry = {
+export interface EngineSummaryEntry {
     readonly engine: string;
     readonly status: 'ok' | 'timeout' | 'error';
     readonly resultCount: number;
     readonly durationMs: number;
-};
-export type SearchWebResult = {
+}
+export interface SearchWebResult {
     readonly results: ReadonlyArray<WebSearchResult>;
     readonly engineSummary: ReadonlyArray<EngineSummaryEntry>;
-};
+}
 export declare function classifyEngineError(reason: unknown): 'timeout' | 'error';
-export declare function searchWeb(fetcher: Fetcher, query: string, maxResults?: number, signal?: BareAbortSignal): Promise<SearchWebResult>;
+export interface SearchWebOptions {
+    readonly maxResults?: number;
+    readonly signal?: BareAbortSignal;
+}
+export declare function searchWeb(fetcher: Fetcher, query: string, { maxResults, signal }?: SearchWebOptions): Promise<SearchWebResult>;

package/dist-lib/lib/web-search/orchestrator.js

@@ -4,7 +4,7 @@ import { mergeResults } from './merge-results.js';
 export function classifyEngineError(reason) {
     return reason instanceof TimeoutError ? 'timeout' : 'error';
 }
-function processSettledResult(engineName, result, outcomes, engineSummary) {
+function processSettledResult(engineName, result, { outcomes, engineSummary }) {
     if (result.status === 'fulfilled') {
         outcomes.push(result.value);
         engineSummary.push({
@@ -23,7 +23,7 @@ function processSettledResult(engineName, result, outcomes, engineSummary) {
         });
     }
 }
-export async function searchWeb(fetcher, query, maxResults = DEFAULT_MAX_RESULTS, signal) {
+export async function searchWeb(fetcher, query, { maxResults = DEFAULT_MAX_RESULTS, signal } = {}) {
     const settled = await Promise.allSettled(ENGINES.map(async ({ name, fn }) => {
         const start = Date.now();
         const results = await fn(query, fetcher, signal);
@@ -41,7 +41,7 @@ export async function searchWeb(fetcher, query, maxResults = DEFAULT_MAX_RESULTS
         if (!engine || !settledResult) {
             continue;
         }
-        processSettledResult(engine.name, settledResult, outcomes, engineSummary);
+        processSettledResult(engine.name, settledResult, { outcomes, engineSummary });
     }
     if (outcomes.length === 0) {
         return { results: [], engineSummary };

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

@@ -44,8 +44,9 @@ export declare function toWire(event: HarnessEvent): WireEvent;
 export declare function fromWire(event: WireEvent): HarnessEvent;
 export declare function toDownloadWire(event: HarnessEvent): WireDownloadEvent;
 export declare function fromDownloadWire(event: WireDownloadEvent): HarnessEvent;
-export declare function packVectors(vectors: number[][]): {
+export interface PackedVectors {
     dimensions: number;
     vectors: Buffer;
-};
+}
+export declare function packVectors(vectors: number[][]): PackedVectors;
 export declare function unpackVectors(dimensions: number, bytes: Buffer): number[][];

package/dist-lib/lib/wire.js

@@ -1,4 +1,14 @@
 import b4a from 'b4a';
+import { isRecord } from './guards.js';
+function stringField(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function objectField(value) {
+    return isRecord(value) ? value : {};
+}
+function isResource(value) {
+    return isRecord(value) && typeof value.kind === 'string' && typeof value.label === 'string';
+}
 export function toWire(event) {
     switch (event.type) {
         case 'content':
@@ -7,26 +17,26 @@ export function toWire(event) {
         case 'tool-call':
             return {
                 type: 'tool-call',
-                name: event.name,
+                name: stringField(event.name),
                 arguments: event.args,
-                rawCall: event.rawCall ?? null,
-                effect: event.effect ?? null,
+                rawCall: stringField(event.rawCall) ?? null,
+                effect: stringField(event.effect) ?? null,
                 display: event.display
             };
         case 'tool-result':
             return {
                 type: 'tool-result',
-                name: event.name,
+                name: stringField(event.name),
                 result: event.result
             };
         case 'tool-activity':
             return {
                 type: 'tool-activity',
-                name: event.name,
+                name: stringField(event.name),
                 arguments: event.args,
-                resource: event.resource ?? null,
-                effect: event.effect,
-                decision: event.decision
+                resource: isResource(event.resource) ? event.resource : null,
+                effect: stringField(event.effect),
+                decision: stringField(event.decision)
             };
         case 'metrics': {
             const { type, ...metrics } = event;
@@ -64,9 +74,7 @@ export function fromWire(event) {
                 type: 'tool-call',
                 name: event.name ?? '',
                 args: event.arguments ?? {},
-                ...(event.rawCall === null || event.rawCall === undefined
-                    ? {}
-                    : { rawCall: event.rawCall }),
+                rawCall: event.rawCall ?? undefined,
                 effect: event.effect === 'read' ? 'read' : 'write',
                 display: event.display ?? undefined
             };
@@ -86,11 +94,11 @@ export function fromWire(event) {
                 decision: event.decision || 'blocked'
             };
         case 'metrics':
-            return { type: 'metrics', ...event.metrics };
+            return { type: 'metrics', ...objectField(event.metrics) };
         case 'inference-call':
             return { type: 'inference-call', call: event.payload };
         case 'inference-sent': {
-            const sent = (event.payload ?? {});
+            const sent = objectField(event.payload);
             return {
                 type: 'inference-sent',
                 messages: sent.messages,
@@ -118,7 +126,7 @@ export function toDownloadWire(event) {
         case 'complete':
             return {
                 type: 'complete',
-                assetId: event.assetId,
+                assetId: stringField(event.assetId),
                 downloaded: typeof event.downloaded === 'boolean' ? event.downloaded : undefined
             };
         case 'error':
@@ -132,7 +140,7 @@ export function toDownloadWire(event) {
 export function fromDownloadWire(event) {
     switch (event.type) {
         case 'progress':
-            return { type: 'progress', ...(event.progress ?? {}) };
+            return { type: 'progress', ...objectField(event.progress) };
         case 'complete':
             return { type: 'complete', assetId: event.assetId ?? '', downloaded: event.downloaded };
         case 'error':

package/dist-lib/schema/baseline.js

@@ -7,28 +7,33 @@ export function rewindSpec(root, dirs, { carries, keep }) {
     if (process.env.SCHEMA_NO_BASELINE)
         return [];
     const baselines = previousReleaseTags(root, { carries });
-    if (baselines.length === 0)
+    if (baselines.length === 0) {
         return [];
+    }
     const held = keep.map((file) => {
         const target = path.join(root, file);
         return { target, contents: fs.readFileSync(target) };
     });
-    for (const dir of dirs)
+    for (const dir of dirs) {
         checkoutSpec(root, dir, baselines[0]);
-    for (const { target, contents } of held)
+    }
+    for (const { target, contents } of held) {
         fs.writeFileSync(target, contents);
+    }
     return baselines;
 }
 function checkoutSpec(root, dir, tag) {
     console.log(`rewinding ${path.relative(root, dir)} to ${tag}`);
     const done = spawnSync('git', ['checkout', tag, '--', dir], { cwd: root });
-    if (done.status !== 0)
+    if (done.status !== 0) {
         throw new Error(`checkout ${tag} failed: ${done.stderr ?? ''}`);
+    }
 }
 export function unstageSpec(root, dirs) {
     const done = spawnSync('git', ['reset', '--quiet', 'HEAD', '--', ...dirs], { cwd: root });
-    if (done.status !== 0)
+    if (done.status !== 0) {
         throw new Error(`git reset -- spec failed: ${done.stderr ?? ''}`);
+    }
 }
 export function resetHrpcIds(hrpcDir) {
     fs.rmSync(path.join(hrpcDir, 'hrpc.json'), { force: true });

package/dist-lib/schema/build.js

@@ -34,6 +34,7 @@ registerHarnessApi(builder.namespace('harness'));
 HRPCBuilder.toDisk(builder);
 writeBind(builder, path.join(SPEC_DIR, 'bind.js'));
 writeClient(builder, path.join(SPEC_DIR, 'calls.js'), 'harnessClient');
-if (baselines.length > 0)
+if (baselines.length > 0) {
     unstageSpec(ROOT, BASELINE_DIRS);
+}
 console.log('harness contract spec generated under spec/');

package/dist-lib/schema/harness.d.ts

@@ -1,2 +1,15 @@
-export declare function registerHarnessTypes(ns: any): void;
-export declare function registerHarnessApi(api: any): void;
+import type Hyperschema from 'hyperschema';
+interface HrpcRoute {
+    name: string;
+    stream: boolean;
+}
+interface HrpcNamespace {
+    register(description: {
+        name: string;
+        request: HrpcRoute;
+        response: HrpcRoute;
+    }): void;
+}
+export declare function registerHarnessTypes(ns: Hyperschema.Namespace): void;
+export declare function registerHarnessApi(api: HrpcNamespace): void;
+export {};

package/dist-lib/schema/harness.js

@@ -338,7 +338,8 @@ export function registerHarnessTypes(ns) {
             { name: 'isLoaded', type: 'bool', required: true },
             { name: 'supportsImages', type: 'bool', required: true },
             { name: 'expectedSize', type: 'uint', required: true },
-            { name: 'actualSize', type: 'uint' }
+            { name: 'actualSize', type: 'uint' },
+            { name: 'label', type: 'string' }
         ]
     });
     ns.register({
@@ -566,7 +567,9 @@ export function registerHarnessTypes(ns) {
             { name: 'src', type: 'string', required: true },
             { name: 'projectionSrc', type: 'string' },
             { name: 'taskType', type: 'string' },
-            { name: 'expectedSize', type: 'uint' }
+            { name: 'expectedSize', type: 'uint' },
+            { name: 'label', type: 'string' },
+            { name: 'contextLength', type: 'uint' }
         ]
     });
     ns.register({
@@ -714,6 +717,25 @@ export function registerHarnessTypes(ns) {
             { name: 'mmprojSrc', type: 'string' }
         ]
     });
+    ns.register({
+        name: 'set-model-idle-timeout-request',
+        fields: [{ name: 'ms', type: 'uint', required: true }]
+    });
+    ns.register({
+        name: 'load-model-response',
+        fields: [
+            { name: 'loaded', type: 'bool', required: true },
+            { name: 'reason', type: 'string' }
+        ]
+    });
+    ns.register({
+        name: 'unload-model-request',
+        fields: [{ name: 'model', type: 'string', required: true }]
+    });
+    ns.register({
+        name: 'unload-model-response',
+        fields: [{ name: 'unloaded', type: 'bool', required: true }]
+    });
 }
 export function registerHarnessApi(api) {
     api.register({
@@ -866,4 +888,19 @@ export function registerHarnessApi(api) {
         request: { name: '@harness/preview-model-source-request', stream: false },
         response: { name: '@harness/preview-model-source-response', stream: false }
     });
+    api.register({
+        name: 'set-model-idle-timeout',
+        request: { name: '@harness/set-model-idle-timeout-request', stream: false },
+        response: { name: '@harness/ok-response', stream: false }
+    });
+    api.register({
+        name: 'load-model',
+        request: { name: '@harness/warm-model-request', stream: false },
+        response: { name: '@harness/load-model-response', stream: false }
+    });
+    api.register({
+        name: 'unload-model',
+        request: { name: '@harness/unload-model-request', stream: false },
+        response: { name: '@harness/unload-model-response', stream: false }
+    });
 }

package/dist-lib/schema/release-tags.d.ts

@@ -1,6 +1,7 @@
 import { Version } from 'bare-semver';
 export declare function currentReleaseVersion(root: string): Version;
-export declare function previousReleaseTags(root: string, { count, carries }: {
+export interface PreviousReleaseTagsOptions {
     count?: number;
     carries: string;
-}): string[];
+}
+export declare function previousReleaseTags(root: string, { count, carries }: PreviousReleaseTagsOptions): string[];

package/dist-lib/schema/release-tags.js

@@ -16,13 +16,15 @@ const TAG_PREFIX = 'v';
 export function previousReleaseTags(root, { count = 3, carries }) {
     const current = currentReleaseVersion(root);
     const listed = spawnSync('git', ['tag', '-l', `${TAG_PREFIX}*`], { cwd: root });
-    if (listed.status !== 0)
+    if (listed.status !== 0) {
         throw new Error(`git tag -l failed: ${listed.stderr ?? ''}`);
+    }
     const newestPerLine = new Map();
     for (const line of (listed.stdout?.toString() ?? '').split('\n')) {
         const parsed = parseTag(line.trim());
-        if (!parsed || Version.compare(parsed.version, current) > 0)
+        if (!parsed || Version.compare(parsed.version, current) > 0) {
             continue;
+        }
         const winner = newestPerLine.get(parsed.line);
         if (!winner || Version.compare(parsed.version, winner.version) > 0) {
             newestPerLine.set(parsed.line, parsed);
@@ -46,8 +48,9 @@ function parseTag(name) {
         return null;
     try {
         const version = Version.parse(name.slice(TAG_PREFIX.length));
-        if (version.prerelease.length > 0)
+        if (version.prerelease.length > 0) {
             return null;
+        }
         return { tag: name, version, line: `${version.major}.${version.minor}` };
     }
     catch {

package/dist-lib/spec/bind.js

@@ -130,4 +130,13 @@ export function bindApi(rpc, api) {
   if (api.previewModelSource) {
     rpc.onPreviewModelSource((req) => api.previewModelSource(req));
   }
+  if (api.setModelIdleTimeout) {
+    rpc.onSetModelIdleTimeout((req) => api.setModelIdleTimeout(req));
+  }
+  if (api.loadModel) {
+    rpc.onLoadModel((req) => api.loadModel(req));
+  }
+  if (api.unloadModel) {
+    rpc.onUnloadModel((req) => api.unloadModel(req));
+  }
 }

package/dist-lib/spec/calls.js

@@ -40,5 +40,8 @@ export function harnessClient(rpc) {
     deleteKvCache: (input) => rpc.deleteKvCache(input),
     detectLanguage: (input) => rpc.detectLanguage(input),
     previewModelSource: (input) => rpc.previewModelSource(input),
+    setModelIdleTimeout: (input) => rpc.setModelIdleTimeout(input),
+    loadModel: (input) => rpc.loadModel(input),
+    unloadModel: (input) => rpc.unloadModel(input),
   };
 }

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

@@ -390,6 +390,45 @@
         "stream": false
       },
       "version": 1
+    },
+    {
+      "id": 30,
+      "name": "@harness/set-model-idle-timeout",
+      "request": {
+        "name": "@harness/set-model-idle-timeout-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@harness/ok-response",
+        "stream": false
+      },
+      "version": 1
+    },
+    {
+      "id": 31,
+      "name": "@harness/load-model",
+      "request": {
+        "name": "@harness/warm-model-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@harness/load-model-response",
+        "stream": false
+      },
+      "version": 1
+    },
+    {
+      "id": 32,
+      "name": "@harness/unload-model",
+      "request": {
+        "name": "@harness/unload-model-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@harness/unload-model-response",
+        "stream": false
+      },
+      "version": 1
     }
   ]
 }

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

@@ -65,7 +65,13 @@ const methods = new Map([
   ['@harness/detect-language', 28],
   [28, '@harness/detect-language'],
   ['@harness/preview-model-source', 29],
-  [29, '@harness/preview-model-source']
+  [29, '@harness/preview-model-source'],
+  ['@harness/set-model-idle-timeout', 30],
+  [30, '@harness/set-model-idle-timeout'],
+  ['@harness/load-model', 31],
+  [31, '@harness/load-model'],
+  ['@harness/unload-model', 32],
+  [32, '@harness/unload-model']
 ])
 
 class HRPC {
@@ -102,7 +108,10 @@ class HRPC {
       ['@harness/delete-overlay-skill', getEncoding('@harness/skill-name-request')],
       ['@harness/delete-kv-cache', getEncoding('@harness/kv-cache-delete-request')],
       ['@harness/detect-language', getEncoding('@harness/detect-language-request')],
-      ['@harness/preview-model-source', getEncoding('@harness/preview-model-source-request')]
+      ['@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')]
     ])
     this._responseEncodings = new Map([
       ['@harness/completion', getEncoding('@harness/completion-event')],
@@ -134,7 +143,10 @@ class HRPC {
       ['@harness/delete-overlay-skill', getEncoding('@harness/delete-skill-response')],
       ['@harness/delete-kv-cache', getEncoding('@harness/kv-cache-deletion-response')],
       ['@harness/detect-language', getEncoding('@harness/detect-language-response')],
-      ['@harness/preview-model-source', getEncoding('@harness/preview-model-source-response')]
+      ['@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')]
     ])
     this._rpc = new RPC(stream, async (req) => {
       const command = methods.get(req.command)
@@ -352,6 +364,18 @@ class HRPC {
     return this._call('@harness/preview-model-source', args)
   }
 
+  async setModelIdleTimeout(args) {
+    return this._call('@harness/set-model-idle-timeout', args)
+  }
+
+  async loadModel(args) {
+    return this._call('@harness/load-model', args)
+  }
+
+  async unloadModel(args) {
+    return this._call('@harness/unload-model', args)
+  }
+
   onCompletion(responseFn) {
     this._handlers['@harness/completion'] = responseFn
   }
@@ -472,6 +496,18 @@ class HRPC {
     this._handlers['@harness/preview-model-source'] = responseFn
   }
 
+  onSetModelIdleTimeout(responseFn) {
+    this._handlers['@harness/set-model-idle-timeout'] = responseFn
+  }
+
+  onLoadModel(responseFn) {
+    this._handlers['@harness/load-model'] = responseFn
+  }
+
+  onUnloadModel(responseFn) {
+    this._handlers['@harness/unload-model'] = responseFn
+  }
+
   _requestIsStream(command) {
     return [
       '@harness/completion',