@qvac/harness 0.4.0 → 0.6.0

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

@@ -7,18 +7,18 @@ export type DownloadProgressEvent = {
     type: 'progress';
     transferred?: boolean;
 } & DownloadProgress;
-export type DownloadCompleteEvent = {
+export interface DownloadCompleteEvent {
     type: 'complete';
     assetId: string;
     downloaded?: boolean;
-};
-export type DownloadErrorEvent = {
+}
+export interface DownloadErrorEvent {
     type: 'error';
     message: string;
-};
-export type DownloadAbortedEvent = {
+}
+export interface DownloadAbortedEvent {
     type: 'aborted';
-};
+}
 export type DownloadEvent = DownloadProgressEvent | DownloadCompleteEvent | DownloadErrorEvent | DownloadAbortedEvent;
 export interface DownloadSdk extends ModelRegistrySdk {
     downloadAsset(options: {

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

@@ -1,5 +1,5 @@
 import { Readable } from 'streamx';
-import { errorMessage } from '../error-fields.js';
+import { errorMessage } from '../guards.js';
 import { resolveModelSrc } from '../models/model-source.js';
 const noop = () => { };
 export function download(sdkOrLoader, args, onSettled) {
@@ -30,12 +30,14 @@ export function download(sdkOrLoader, args, onSettled) {
         finish({ type: 'aborted' });
     };
     const onProgress = (p) => {
-        if (!settled)
+        if (!settled) {
             stream.push({ ...p, type: 'progress', transferred });
+        }
     };
     const start = async () => {
-        if (signal?.aborted)
+        if (signal?.aborted) {
             return finish({ type: 'aborted' });
+        }
         try {
             sdkRef = await loadSdk();
             const resolved = await resolveModelSrc(sdkRef, model, addon);
@@ -44,8 +46,9 @@ export function download(sdkOrLoader, args, onSettled) {
             const aggregate = aggregateLayout(srcs, assetSizes);
             let mainAssetId = '';
             for (let i = 0; i < srcs.length; i++) {
-                if (signal?.aborted)
+                if (signal?.aborted) {
                     return finish({ type: 'aborted' });
+                }
                 const progress = aggregate
                     ? aggregateProgressHandler(onProgress, {
                         setKey: mainSrc,
@@ -61,23 +64,26 @@ export function download(sdkOrLoader, args, onSettled) {
                     assetSrc: srcs[i],
                     seed,
                     onProgress: (update) => {
-                        if (update.percentage < 100)
+                        if (update.percentage < 100) {
                             transferred = true;
+                        }
                         progress(update);
                     }
                 });
                 requestId = op.requestId;
                 const assetId = await op;
-                if (i === 0)
+                if (i === 0) {
                     mainAssetId = assetId;
+                }
             }
             opDone = true;
             finish({ type: 'complete', assetId: mainAssetId, downloaded: transferred });
         }
         catch (err) {
             opDone = true;
-            if (signal?.aborted)
+            if (signal?.aborted) {
                 return finish({ type: 'aborted' });
+            }
             finish({ type: 'error', message: errorMessage(err) });
         }
     };
@@ -103,8 +109,9 @@ function aggregateLayout(sources, assetSizes) {
     let totalBytes = 0;
     for (const source of sources) {
         const size = assetSizes[source];
-        if (!Number.isFinite(size) || size <= 0)
+        if (!Number.isFinite(size) || size <= 0) {
             return null;
+        }
         offsets.push(totalBytes);
         sizes.push(size);
         totalBytes += size;

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

@@ -7,7 +7,8 @@ export function createEmbedLane() {
             const { embedding } = await sdk.embed({ modelId, text: texts });
             return embedding;
         });
-        tail = job.catch(() => { });
+        tail = job.catch(noop);
         return job;
     };
 }
+function noop() { }

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

@@ -7,4 +7,9 @@ export interface EnhanceResult {
     totalTokens?: number;
 }
 export type Enhancer = (prompt: string, signal?: BareAbortSignal) => Promise<EnhanceResult | null>;
-export declare function expandImagePrompt(sdk: CompletionSdk, modelId: string, model: string, prompt: string, signal?: BareAbortSignal): Promise<EnhanceResult | null>;
+export interface ExpandImagePromptOptions {
+    modelId: string;
+    model: string;
+    signal?: BareAbortSignal | undefined;
+}
+export declare function expandImagePrompt(sdk: CompletionSdk, prompt: string, { modelId, model, signal }: ExpandImagePromptOptions): Promise<EnhanceResult | null>;

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

@@ -3,7 +3,7 @@ import { raceAbort } from '../helpers/race-abort.js';
 const SYSTEM = "Rewrite the user's description as a single vivid prompt for an image generator. " +
     'Answer with the prompt alone: no preamble, no quotes, no explanation.';
 const MAX_PROMPT_CHARS = 400;
-export async function expandImagePrompt(sdk, modelId, model, prompt, signal) {
+export async function expandImagePrompt(sdk, prompt, { modelId, model, signal }) {
     const run = sdk.completion({
         modelId,
         history: [
@@ -18,12 +18,15 @@ export async function expandImagePrompt(sdk, modelId, model, prompt, signal) {
         final = await raceAbort(run.final, signal);
     }
     catch (err) {
-        if (run.requestId)
-            void sdk.cancel?.({ requestId: run.requestId }).catch(() => { });
+        if (run.requestId) {
+            void sdk.cancel?.({ requestId: run.requestId }).catch(noop);
+        }
         throw err;
     }
     const text = cleanAnswer(final.contentText).slice(0, MAX_PROMPT_CHARS);
-    if (!text)
+    if (!text) {
         return null;
+    }
     return { text, model, totalTokens: final.stats?.generatedTokens };
 }
+function noop() { }

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

@@ -1,9 +1,10 @@
+import { errorMessage } from '../guards.js';
 import { AbortedError } from '../helpers/race-abort.js';
 const CAPABILITY_TOOLS = {
     image: { tool: 'generate_image', enhances: 'prompt' },
     translate: { tool: 'translate' }
 };
-export const CAPABILITIES = Object.keys(CAPABILITY_TOOLS);
+export const CAPABILITIES = Object.keys(CAPABILITY_TOOLS).filter(isCapability);
 export function isCapability(name) {
     return name in CAPABILITY_TOOLS;
 }
@@ -30,13 +31,15 @@ export async function* invoke({ capability, args, tools, ctx, enhance = 'never',
             }
         }
     }
-    if (ctx.signal?.aborted)
+    if (ctx.signal?.aborted) {
         return yield { type: 'aborted' };
+    }
     yield { type: 'tool-call', name: entry.tool, args: called, effect: tool.effect(called, ctx) };
     try {
         const result = await tool.execute(called, ctx);
-        if (ctx.signal?.aborted)
+        if (ctx.signal?.aborted) {
             return yield { type: 'aborted' };
+        }
         yield { type: 'tool-result', name: entry.tool, result };
     }
     catch (err) {
@@ -44,7 +47,7 @@ export async function* invoke({ capability, args, tools, ctx, enhance = 'never',
             yield { type: 'aborted' };
             return;
         }
-        yield { type: 'error', message: err instanceof Error ? err.message : String(err) };
+        yield { type: 'error', message: errorMessage(err) };
         return;
     }
     yield {

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

@@ -1,3 +1,4 @@
+import { errorMessage } from '../guards.js';
 export async function deleteAllKvCaches(loadSdk) {
     return deleteCacheWith(loadSdk, { all: true });
 }
@@ -15,7 +16,7 @@ async function deleteCacheWith(loadSdk, params) {
     catch (error) {
         return {
             status: 'failure',
-            error: error instanceof Error ? error.message : String(error)
+            error: errorMessage(error)
         };
     }
 }

package/dist-lib/lib/capabilities/preview-model-source.d.ts

@@ -48,13 +48,15 @@ export interface FitQuery {
 }
 export interface PreviewDeps {
     fetch?: PreviewFetch;
-    stat?(path: string): Promise<{
-        size: number;
-    } | null>;
-    assessFit?(query: FitQuery): Promise<{
-        fit: ModelFitVerdict;
-        fitReasons: string[];
-    }>;
+    stat?(path: string): Promise<FileStat | null>;
+    assessFit?(query: FitQuery): Promise<FitAssessment>;
+}
+export interface FileStat {
+    size: number;
+}
+export interface FitAssessment {
+    fit: ModelFitVerdict;
+    fitReasons: string[];
 }
 interface HuggingFaceRef {
     repo: string;

package/dist-lib/lib/capabilities/preview-model-source.js

@@ -1,7 +1,9 @@
 import fs from 'fs';
 import defaultFetch from '#fetch';
+import { errorMessage } from '../guards.js';
 import { defaultContextSize } from '../models/context.js';
 import { isRemoteSource, localSourcePath, parseGgufHeader, readGgufHeaderBytes } from '../models/gguf-header.js';
+import { shardSet } from '../models/shards.js';
 const HUGGING_FACE = 'https://huggingface.co';
 const HUGGING_FACE_HOSTS = new Set(['huggingface.co', 'www.huggingface.co', 'hf.co']);
 const NON_MODEL_NAMESPACES = new Set(['api', 'datasets', 'spaces', 'docs', 'models']);
@@ -32,11 +34,13 @@ export async function previewModelSource(context, deps = {}) {
         return refuse('invalid-source', 'Paste a Hugging Face link, a direct link to a .gguf file, or a local path.');
     }
     const weight = await inspectModelFile(src, fetch, deps);
-    if ('answer' in weight)
+    if ('answer' in weight) {
         return weight.answer;
+    }
     const problem = modelProblem(weight.header);
-    if (problem)
+    if (problem) {
         return refuse(problem[0], problem[1]);
+    }
     const taskType = taskTypeFor({
         pipelineTag: weight.file.pipelineTag,
         tags: [...(weight.file.tags ?? []), ...(weight.header.tags ?? [])],
@@ -58,7 +62,7 @@ export async function previewModelSource(context, deps = {}) {
         projectionBytes = projection.file.sizeBytes;
         projectionSrc = projection.file.src;
     }
-    const { fit, fitReasons } = await assess(weight.file, weight.header, taskType, deps);
+    const { fit, fitReasons } = await assess(weight, taskType, deps);
     return defined({
         ok: true,
         src: weight.file.src,
@@ -105,14 +109,17 @@ export function parseHuggingFaceRef(src) {
     catch {
         return null;
     }
-    if (!HUGGING_FACE_HOSTS.has(url.hostname))
+    if (!HUGGING_FACE_HOSTS.has(url.hostname)) {
         return null;
+    }
     const segments = pathSegments(url.pathname);
-    if (!segments)
+    if (!segments) {
         return null;
+    }
     const [org, name, kind, revision, ...rest] = segments;
-    if (!org || !name || NON_MODEL_NAMESPACES.has(org))
+    if (!org || !name || NON_MODEL_NAMESPACES.has(org)) {
         return null;
+    }
     const repo = `${org}/${name}`;
     if (!kind) {
         const shown = url.searchParams.get('show_file_info');
@@ -121,17 +128,17 @@ export function parseHuggingFaceRef(src) {
     if ((kind === 'blob' || kind === 'resolve') && revision && rest.length > 0) {
         return { repo, revision, file: rest.join('/') };
     }
-    if (kind === 'tree' && revision)
+    if (kind === 'tree' && revision) {
         return { repo, revision };
+    }
     return null;
 }
 async function inspectModelFile(src, fetch, deps) {
     const inspection = await inspect(src, fetch, deps);
-    if (inspection.kind === 'answer')
+    if (inspection.kind === 'answer') {
         return { answer: inspection.preview };
-    const bytes = await readGgufHeaderBytes(inspection.file.src, {
-        fetch: fetch
-    });
+    }
+    const bytes = await readGgufHeaderBytes(inspection.file.src, { fetch });
     if (!bytes) {
         return {
             answer: refuse('unreachable', 'Could not read the start of the file to check it is a model.')
@@ -147,8 +154,9 @@ async function inspectModelFile(src, fetch, deps) {
 }
 function inspect(src, fetch, deps) {
     const ref = parseHuggingFaceRef(src);
-    if (ref)
+    if (ref) {
         return inspectHuggingFace(ref, fetch);
+    }
     if (isRemoteSource(src)) {
         return wellFormedUrl(src)
             ? inspectUrl(src, fetch)
@@ -191,8 +199,9 @@ async function inspectHuggingFace(ref, fetch) {
     const wanted = ref.file;
     if (wanted) {
         const sibling = siblings.find((entry) => entry.rfilename === wanted);
-        if (!sibling)
+        if (!sibling) {
             return answer(refuse('not-found', `${ref.repo} has no file ${wanted}.`));
+        }
         if (!/\.gguf$/i.test(wanted)) {
             return answer(refuse('not-gguf', `${wanted} is not a GGUF file. Only GGUF models run on this device.`));
         }
@@ -236,15 +245,45 @@ async function inspectUrl(src, fetch) {
     if ((response.headers.get('content-type') ?? '').includes('text/html')) {
         return answer(refuse('web-page', 'This link opens a web page, not a model file. Link to the .gguf file itself.'));
     }
-    const sizeBytes = positive(response.headers.get('x-linked-size')) ??
+    const set = shardSet(src);
+    if (set && set.shards.length > 1) {
+        return inspectShards(set, fetch);
+    }
+    return { kind: 'file', file: { src, label: basename(src), sizeBytes: sizeOfResponse(response) } };
+}
+async function inspectShards(set, fetch) {
+    let responses;
+    try {
+        responses = await Promise.all(set.shards.map((shard) => fetch(shard.url, { method: 'HEAD', redirect: 'follow' })));
+    }
+    catch {
+        return answer(refuse('unreachable', `Could not reach every part of ${set.base}.`));
+    }
+    const missing = responses.findIndex((response) => !response.ok);
+    if (missing !== -1) {
+        const { status } = responses[missing];
+        return answer(refuse(status === 404 || status === 410 ? 'not-found' : 'unreachable', `Part ${missing + 1} of ${set.shards.length}, ${set.shards[missing].filename}, answered HTTP ${status}.`));
+    }
+    const sizes = responses.map(sizeOfResponse);
+    return {
+        kind: 'file',
+        file: {
+            src: set.shards[0].url,
+            label: `${set.base}${set.extension} (${set.shards.length} parts)`,
+            sizeBytes: sizes.includes(0) ? 0 : sizes.reduce((sum, size) => sum + size, 0)
+        }
+    };
+}
+function sizeOfResponse(response) {
+    return (positive(response.headers.get('x-linked-size')) ??
         positive(response.headers.get('content-length')) ??
-        0;
-    return { kind: 'file', file: { src, label: basename(src), sizeBytes } };
+        0);
 }
 async function inspectLocal(src, file, deps) {
     const stat = await (deps.stat ?? statFile)(file);
-    if (!stat)
+    if (!stat) {
         return answer(refuse('not-found', `There is no file at ${file}.`));
+    }
     return { kind: 'file', file: { src, label: basename(file), sizeBytes: stat.size } };
 }
 async function statFile(file) {
@@ -261,8 +300,9 @@ function modelFiles(ref, siblings) {
     const shardSets = new Map();
     for (const sibling of siblings) {
         const name = sibling.rfilename;
-        if (!/\.gguf$/i.test(name) || /mmproj/i.test(name))
+        if (!/\.gguf$/i.test(name) || /mmproj/i.test(name)) {
             continue;
+        }
         const shard = SHARD.exec(name);
         if (!shard) {
             singles.push({ ...fileOf(ref, sibling), members: [name] });
@@ -298,8 +338,9 @@ function modelProblem(header) {
             'This is a vision projection (mmproj), not a model. Add the model file and pass this as its projection.'
         ];
     }
-    if (header.type === 'adapter')
+    if (header.type === 'adapter') {
         return ['not-a-model', 'This is a LoRA adapter, not a model.'];
+    }
     return null;
 }
 function isProjection(header) {
@@ -307,28 +348,32 @@ function isProjection(header) {
 }
 function taskTypeFor({ pipelineTag, tags = [], architecture }) {
     const tagged = [pipelineTag, ...tags].find((tag) => tag !== undefined && Object.hasOwn(PIPELINE_TASKS, tag));
-    if (tagged)
+    if (tagged) {
         return PIPELINE_TASKS[tagged];
+    }
     return ARCHITECTURE_TASKS.find(([pattern]) => pattern.test(architecture ?? ''))?.[1] ?? 'llm';
 }
-async function assess(file, header, taskType, deps) {
-    if (taskType !== 'llm')
+async function assess({ file, header }, taskType, deps) {
+    if (taskType !== 'llm') {
         return { fit: 'unknown', fitReasons: [NOT_LLM_REASON] };
-    if (!file.sha256)
+    }
+    if (!file.sha256) {
         return { fit: 'unknown', fitReasons: [NO_CHECKSUM_REASON] };
-    if (!deps.assessFit)
+    }
+    if (!deps.assessFit) {
         return { fit: 'unknown', fitReasons: [NO_ESTIMATOR_REASON] };
+    }
     try {
         return await deps.assessFit({
             sha256Checksum: file.sha256,
             name: header.name ?? file.label,
-            contextTokens: Math.min(header.contextLength || defaultContextSize(file.src), defaultContextSize(file.src))
+            contextTokens: defaultContextSize(file.src, header.contextLength)
         });
     }
     catch (err) {
         return {
             fit: 'unknown',
-            fitReasons: [`The fit estimate failed: ${err instanceof Error ? err.message : String(err)}`]
+            fitReasons: [`The fit estimate failed: ${errorMessage(err)}`]
         };
     }
 }
@@ -360,8 +405,9 @@ function wellFormedUrl(src) {
 }
 function licenseOf(info) {
     const license = info.cardData?.license;
-    if (Array.isArray(license))
+    if (Array.isArray(license)) {
         return license.length ? license.join(', ') : undefined;
+    }
     return license || undefined;
 }
 function sizeOf(sibling) {
@@ -383,5 +429,11 @@ function answer(preview) {
     return { kind: 'answer', preview };
 }
 function defined(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+    const copy = { ...value };
+    for (const [key, entry] of Object.entries(value)) {
+        if (entry === undefined) {
+            Reflect.deleteProperty(copy, key);
+        }
+    }
+    return copy;
 }

package/dist-lib/lib/capabilities/speech-text.js

@@ -31,9 +31,9 @@ function verbalize(text, lang) {
     let spoken = text.replace(/#(?=\d)/g, ' number ');
     for (const [symbol, code] of CURRENCY_CODES) {
         spoken = spoken.replace(amountAfter(symbol), (_match, amount) => {
-            return ` ${amount} ${currencyName(code, lang, amount === '1')} `;
+            return ` ${amount} ${currencyName(code, lang, { singular: amount === '1' })} `;
         });
-        spoken = spoken.split(symbol).join(` ${currencyName(code, lang, false)} `);
+        spoken = spoken.split(symbol).join(` ${currencyName(code, lang)} `);
     }
     for (const [symbol, spokenForm] of SPEECH_LEXICON[lang]) {
         spoken = spoken.split(symbol).join(spokenForm);
@@ -46,11 +46,12 @@ function amountAfter(symbol) {
 function escapeRegExp(text) {
     return text.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
 }
-function currencyName(code, lang, singular) {
+function currencyName(code, lang, { singular = false } = {}) {
     const key = `${lang}:${code}:${singular}`;
     const hit = CURRENCY_NAMES.get(key);
-    if (hit !== undefined)
+    if (hit !== undefined) {
         return hit;
+    }
     const parts = new Intl.NumberFormat(lang, {
         style: 'currency',
         currency: code,

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

@@ -13,12 +13,10 @@ export function collectToolGrants(skills) {
             const owners = grants.grantedOwners.get(name) ?? new Set();
             owners.add(skill.name);
             grants.grantedOwners.set(name, owners);
-            if (scope) {
-                if (skill.cliValidator && skill.cliValidator.bin === scope.toLowerCase()) {
-                    const list = grants.grantedOps.get(scope.toLowerCase()) ?? [];
-                    list.push(skill.cliValidator);
-                    grants.grantedOps.set(scope.toLowerCase(), list);
-                }
+            if (scope && skill.cliValidator && skill.cliValidator.bin === scope.toLowerCase()) {
+                const list = grants.grantedOps.get(scope.toLowerCase()) ?? [];
+                list.push(skill.cliValidator);
+                grants.grantedOps.set(scope.toLowerCase(), list);
             }
         }
     }
@@ -49,12 +47,15 @@ export function enabledTools(tools, { toolsSelected, allowlist, grantedNames, gr
         }
         if (tool.rootsRequired)
             return hasRoots;
-        if (tool.writeRootsRequired)
+        if (tool.writeRootsRequired) {
             return hasWriteRoots;
-        if (tool.skillGated)
+        }
+        if (tool.skillGated) {
             return loadedGrantedNames.has(tool.name);
-        if (!toolsSelected)
+        }
+        if (!toolsSelected) {
             return true;
+        }
         return allowlist.includes(tool.name) || grantedNames.has(tool.name);
     });
 }

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

@@ -1,3 +1,4 @@
+import { isRecord } from '../guards.js';
 import { SKILL_TOOL_NAME } from './tool-names.js';
 export const DIRECT_CALL_ID = 'call-direct';
 export const TOOL_CONTINUATION_NUDGE = "[Tool results above. Continue the user's request: call the next tool, or answer.]";
@@ -13,37 +14,43 @@ export function skillLoadedTurn(name) {
 function refFrom(value) {
     if (!value || typeof value !== 'object')
         return null;
-    const record = value;
-    if (typeof record.attachmentId !== 'string')
+    if (!('attachmentId' in value) || typeof value.attachmentId !== 'string') {
         return null;
-    const ref = { attachmentId: record.attachmentId };
-    const name = typeof record.fileName === 'string' ? record.fileName : '';
+    }
+    const ref = { attachmentId: value.attachmentId };
+    const name = 'fileName' in value && typeof value.fileName === 'string' ? value.fileName : '';
     const dot = name.lastIndexOf('.');
-    if (dot > 0)
+    if (dot > 0) {
         ref.type = name.slice(dot + 1).toLowerCase();
+    }
     return ref;
 }
 export function attachmentTurn(name, result) {
     const direct = refFrom(result);
-    if (direct)
+    if (direct) {
         return toolResultTurn(name, DIRECT_CALL_ID, direct);
-    const listed = result?.attachments;
-    if (!Array.isArray(listed))
+    }
+    const listed = isRecord(result) ? result.attachments : undefined;
+    if (!Array.isArray(listed)) {
         return null;
+    }
     const refs = [];
     for (const entry of listed) {
         const ref = refFrom(entry);
-        if (ref)
+        if (ref) {
             refs.push(ref);
+        }
     }
-    if (!refs.length)
+    if (!refs.length) {
         return null;
+    }
     return toolResultTurn(name, DIRECT_CALL_ID, { attachments: refs });
 }
 export function loadedSkillsFrom(messages) {
     const loaded = new Set();
-    for (const { name } of skillLoadPayloads(messages))
+    for (const { name } of skillLoadPayloads(messages)) {
         loaded.add(name);
+    }
     return loaded;
 }
 export function loadedSkillFilesFrom(messages) {
@@ -66,21 +73,27 @@ export function withoutSkillLoadTurns(messages, name) {
 function* skillLoadPayloads(messages) {
     for (const turn of messages) {
         const payload = skillLoadPayload(turn);
-        if (payload)
+        if (payload) {
             yield payload;
+        }
     }
 }
 function skillLoadPayload(turn) {
     if (turn.role !== 'tool')
         return null;
     const text = String(turn.content ?? '');
-    if (!text.startsWith(`[Tool: ${SKILL_TOOL_NAME} (`))
+    if (!text.startsWith(`[Tool: ${SKILL_TOOL_NAME} (`)) {
         return null;
+    }
     try {
         const payload = JSON.parse(text.slice(text.indexOf('\n') + 1));
-        if (typeof payload.name !== 'string')
+        if (typeof payload !== 'object' || payload === null) {
             return null;
-        return typeof payload.file === 'string'
+        }
+        if (!('name' in payload) || typeof payload.name !== 'string') {
+            return null;
+        }
+        return 'file' in payload && typeof payload.file === 'string'
             ? { name: payload.name, file: payload.file }
             : { name: payload.name };
     }
@@ -95,7 +108,8 @@ function historyPayload(output) {
     if (!HOST_ONLY_KEYS.some((key) => key in output))
         return output;
     const rest = { ...output };
-    for (const key of HOST_ONLY_KEYS)
+    for (const key of HOST_ONLY_KEYS) {
         delete rest[key];
+    }
     return rest;
 }

package/dist-lib/lib/capabilities/usage-breakdown.js

@@ -27,8 +27,9 @@ export function usageBreakdown(chars, totalTokens, modelName) {
             : 0
     };
     const prompt = rows.systemPrompt + rows.agentInstructions + rows.activeSkills + rows.tools;
-    if (prompt > totalTokens)
+    if (prompt > totalTokens) {
         return scaledToWindow(rows, totalTokens);
+    }
     return { ...rows, conversation: totalTokens - prompt, totalTokens };
 }
 function scaledToWindow(rows, totalTokens) {

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

@@ -71,7 +71,11 @@ export interface SpeakStreamContext {
 export type VoiceLane = <T>(job: () => Promise<T>) => Promise<T>;
 export declare function createVoiceLane(): VoiceLane;
 export declare function transcribeOnce(sdk: VoiceSdk, modelId: string, audio: Buffer): Promise<string>;
-export declare function transcribeStreaming(sdk: VoiceSdk, modelId: string, pcm: Buffer, signal?: BareAbortSignal): Promise<string>;
+export interface TranscribeStreamingOptions {
+    modelId: string;
+    signal?: BareAbortSignal | undefined;
+}
+export declare function transcribeStreaming(sdk: VoiceSdk, pcm: Uint8Array, { modelId, signal }: TranscribeStreamingOptions): Promise<string>;
 export declare function speakStreamOnce(sdk: VoiceSdk, modelId: string, text: AsyncIterable<string>): AsyncGenerator<SpeakResult>;
 export declare function speakable(text: string): string;
 export declare function speakOnce(sdk: VoiceSdk, modelId: string, text: string): Promise<number[]>;