@qvac/harness 0.3.3 → 0.5.0

package/dist-lib/lib/audio-transcode-bare.d.ts

@@ -1,2 +1,2 @@
-export declare function transcodeToWav16kMono(input: Buffer): Promise<Buffer | null>;
-export declare function transcodeToPcm16kMono(input: Buffer): Promise<Buffer | null>;
+export declare function transcodeToWav16kMono(input: Uint8Array): Promise<Uint8Array | null>;
+export declare function transcodeToPcm16kMono(input: Uint8Array): Promise<Uint8Array | null>;

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

@@ -1,13 +1,16 @@
 import ffmpeg from 'bare-ffmpeg';
+import b4a from 'b4a';
+import { errorMessage } from './guards.js';
 import { hlog } from './log.js';
 import { buildWavBuffer, TARGET_SAMPLE_RATE } from './wav-encode.js';
 function bufferReadIO(input) {
     let offset = 0;
-    return new ffmpeg.IOContext(Buffer.alloc(4096), {
+    return new ffmpeg.IOContext(b4a.alloc(4096), {
         onread: (buffer, requested) => {
             const remaining = input.length - offset;
-            if (remaining <= 0)
+            if (remaining <= 0) {
                 return 0;
+            }
             const n = Math.min(requested, remaining);
             buffer.set(input.subarray(offset, offset + n));
             offset += n;
@@ -45,12 +48,12 @@ function readChunk(samples, outFrame, produced) {
     if (produced <= 0)
         return null;
     samples.read(outFrame);
-    return Buffer.from(samples.data.subarray(0, produced * 2));
+    return b4a.from(samples.data.subarray(0, produced * 2));
 }
 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, rate) {
+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));
@@ -66,19 +69,22 @@ function flushResampler(resampler, samples, rate) {
         const outFrame = makeOutFrame(rate, rate);
         flushed = resampler.flush(outFrame);
         const chunk = readChunk(samples, outFrame, flushed);
-        if (chunk)
+        if (chunk) {
             chunks.push(chunk);
+        }
         outFrame.destroy();
     } while (flushed > 0);
     return chunks;
 }
-function drainDecodedFrames(decoder, frame, samples, resampler, chunks, rate) {
+function drainDecodedFrames(decoder, resampler, target) {
+    const { frame, chunks, rate } = target;
     let current = resampler;
     while (decoder.receiveFrame(frame)) {
         current ??= createResampler(frame, rate);
-        const chunk = convertFrame(current, frame, samples, rate);
-        if (chunk)
+        const chunk = convertFrame(current, target);
+        if (chunk) {
             chunks.push(chunk);
+        }
     }
     return current;
 }
@@ -86,25 +92,27 @@ const YIELD_EVERY_PACKETS = 32;
 function yieldToLoop() {
     return new Promise((resolve) => setTimeout(resolve, 0));
 }
-async function decodeToPcmChunks(inputFormat, stream, decoder, rate) {
+async function decodeToPcmChunks(inputFormat, { stream, decoder, rate }) {
     const chunks = [];
     const packet = new ffmpeg.Packet();
     const flush = new ffmpeg.Packet();
     const frame = new ffmpeg.Frame();
     const samples = new ffmpeg.Samples();
+    const target = { frame, samples, chunks, rate };
     let resampler = null;
     let packets = 0;
     try {
         while (inputFormat.readFrame(packet)) {
             if (packet.streamIndex === stream.index && decoder.sendPacket(packet)) {
-                resampler = drainDecodedFrames(decoder, frame, samples, resampler, chunks, rate);
+                resampler = drainDecodedFrames(decoder, resampler, target);
             }
             packet.unref();
-            if (++packets % YIELD_EVERY_PACKETS === 0)
+            if (++packets % YIELD_EVERY_PACKETS === 0) {
                 await yieldToLoop();
+            }
         }
         decoder.sendPacket(flush);
-        resampler = drainDecodedFrames(decoder, frame, samples, resampler, chunks, rate);
+        resampler = drainDecodedFrames(decoder, resampler, target);
         chunks.push(...flushResampler(resampler, samples, rate));
     }
     finally {
@@ -119,20 +127,22 @@ async function decodeInputToPcm(input, rate) {
     let inputFormat = null;
     let decoder = null;
     try {
-        inputFormat = new ffmpeg.InputFormatContext(bufferReadIO(input));
-        const stream = inputFormat.getBestStream(ffmpeg.constants.mediaTypes.AUDIO);
+        const format = new ffmpeg.InputFormatContext(bufferReadIO(input));
+        inputFormat = format;
+        const stream = format.getBestStream(ffmpeg.constants.mediaTypes.AUDIO);
         decoder = stream.decoder();
         decoder.open();
-        const chunks = await decodeToPcmChunks(inputFormat, stream, decoder, rate);
-        return chunks.length === 0 ? null : Buffer.concat(chunks);
+        const chunks = await decodeToPcmChunks(format, { stream, decoder, rate });
+        return chunks.length === 0 ? null : b4a.concat(chunks);
     }
     catch (e) {
-        hlog('audio decode/resample failed', { error: e instanceof Error ? e.message : String(e) });
+        hlog('audio decode/resample failed', { error: errorMessage(e) });
         return null;
     }
     finally {
-        if (decoder)
+        if (decoder) {
             decoder.destroy();
+        }
         inputFormat?.destroy();
     }
 }

package/dist-lib/lib/audio-transcode-node.d.ts

@@ -1,2 +1,2 @@
-export declare function transcodeToWav16kMono(_input: Buffer): Promise<Buffer | null>;
-export declare function transcodeToPcm16kMono(_input: Buffer): Promise<Buffer | null>;
+export declare function transcodeToWav16kMono(_input: Uint8Array): Promise<Uint8Array | null>;
+export declare function transcodeToPcm16kMono(_input: Uint8Array): Promise<Uint8Array | null>;

package/dist-lib/lib/capabilities/audio-resample.d.ts

@@ -4,11 +4,12 @@ interface WavFormat {
     readonly sampleRate: number;
     readonly bitsPerSample: number;
 }
-export declare function wavFormat(bytes: Buffer): WavFormat | null;
-export declare function needsResample(bytes: Buffer): boolean;
-export declare function resampleForTranscription(bytes: Buffer): Promise<{
-    readonly bytes: Buffer;
+export declare function wavFormat(bytes: Uint8Array): WavFormat | null;
+export declare function needsResample(bytes: Uint8Array): boolean;
+export interface ResampledAudio {
+    readonly bytes: Uint8Array;
     readonly transcoded: boolean;
-}>;
-export declare function pcmForTranscription(bytes: Buffer): Promise<Buffer | null>;
+}
+export declare function resampleForTranscription(bytes: Uint8Array): Promise<ResampledAudio>;
+export declare function pcmForTranscription(bytes: Uint8Array): Promise<Uint8Array | null>;
 export {};

package/dist-lib/lib/capabilities/audio-resample.js

@@ -1,3 +1,4 @@
+import b4a from 'b4a';
 import { transcodeToPcm16kMono, transcodeToWav16kMono } from '#audio-transcode';
 const TARGET_SAMPLE_RATE = 16000;
 const TARGET_CHANNELS = 1;
@@ -6,21 +7,24 @@ const WAV_PCM_FORMAT = 1;
 export function wavFormat(bytes) {
     if (bytes.length < 44)
         return null;
-    if (bytes.toString('ascii', 0, 4) !== 'RIFF')
+    if (b4a.toString(bytes, 'ascii', 0, 4) !== 'RIFF')
         return null;
-    if (bytes.toString('ascii', 8, 12) !== 'WAVE')
+    if (b4a.toString(bytes, 'ascii', 8, 12) !== 'WAVE') {
         return null;
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     return {
-        formatCode: bytes.readUInt16LE(20),
-        channels: bytes.readUInt16LE(22),
-        sampleRate: bytes.readUInt32LE(24),
-        bitsPerSample: bytes.readUInt16LE(34)
+        formatCode: view.getUint16(20, true),
+        channels: view.getUint16(22, true),
+        sampleRate: b4a.readUInt32LE(bytes, 24),
+        bitsPerSample: view.getUint16(34, true)
     };
 }
 function wavNeedsResample(bytes) {
     const fmt = wavFormat(bytes);
-    if (!fmt)
+    if (!fmt) {
         return true;
+    }
     return (fmt.formatCode !== WAV_PCM_FORMAT ||
         fmt.channels !== TARGET_CHANNELS ||
         fmt.sampleRate !== TARGET_SAMPLE_RATE ||
@@ -29,35 +33,42 @@ function wavNeedsResample(bytes) {
 export function needsResample(bytes) {
     if (bytes.length < 12)
         return false;
-    if (bytes.toString('ascii', 0, 4) === 'RIFF' && bytes.toString('ascii', 8, 12) === 'WAVE') {
+    if (b4a.toString(bytes, 'ascii', 0, 4) === 'RIFF' &&
+        b4a.toString(bytes, 'ascii', 8, 12) === 'WAVE') {
         return wavNeedsResample(bytes);
     }
-    if (bytes.toString('ascii', 4, 8) === 'ftyp')
+    if (b4a.toString(bytes, 'ascii', 4, 8) === 'ftyp')
         return true;
-    if (bytes.toString('ascii', 0, 3) === 'ID3')
+    if (b4a.toString(bytes, 'ascii', 0, 3) === 'ID3') {
         return true;
-    if (bytes[0] === 0xff && ((bytes[1] ?? 0) & 0xe0) === 0xe0)
+    }
+    if (bytes[0] === 0xff && ((bytes[1] ?? 0) & 0xe0) === 0xe0) {
         return true;
-    if (bytes.toString('ascii', 0, 4) === 'OggS')
+    }
+    if (b4a.toString(bytes, 'ascii', 0, 4) === 'OggS') {
         return true;
-    if (bytes.toString('ascii', 0, 4) === 'fLaC')
+    }
+    if (b4a.toString(bytes, 'ascii', 0, 4) === 'fLaC') {
         return true;
+    }
     return false;
 }
 export async function resampleForTranscription(bytes) {
-    if (!needsResample(bytes))
+    if (!needsResample(bytes)) {
         return { bytes, transcoded: false };
+    }
     const wav = await transcodeToWav16kMono(bytes);
     return wav ? { bytes: wav, transcoded: true } : { bytes, transcoded: false };
 }
 function wavPcmData(bytes) {
     let offset = 12;
     while (offset + 8 <= bytes.length) {
-        const id = bytes.toString('ascii', offset, offset + 4);
-        const size = bytes.readUInt32LE(offset + 4);
+        const id = b4a.toString(bytes, 'ascii', offset, offset + 4);
+        const size = b4a.readUInt32LE(bytes, offset + 4);
         const start = offset + 8;
-        if (id === 'data')
+        if (id === 'data') {
             return bytes.subarray(start, Math.min(start + size, bytes.length));
+        }
         offset = start + size + (size & 1);
     }
     return null;
@@ -65,8 +76,9 @@ function wavPcmData(bytes) {
 export async function pcmForTranscription(bytes) {
     if (wavFormat(bytes) && !needsResample(bytes)) {
         const pcm = wavPcmData(bytes);
-        if (pcm)
+        if (pcm) {
             return pcm;
+        }
     }
     return transcodeToPcm16kMono(bytes);
 }

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

@@ -10,12 +10,13 @@ import type { SkillCatalogEntry } from '../tools/skills/catalog.ts';
 import { type SkillState } from '../tools/skills/skill-state-constants.ts';
 import type { CliValidator } from '../tools/skills/cli-schema.ts';
 import { type Toolset } from '../tools/toolsets.ts';
+export interface MessageAttachment {
+    path: string;
+}
 export interface Message {
     role: string;
     content: string;
-    attachments?: {
-        path: string;
-    }[];
+    attachments?: MessageAttachment[];
     [key: string]: unknown;
 }
 export interface Agent {
@@ -186,35 +187,35 @@ export interface ToolDefinition {
     compiled?: true;
     execute: (args: Record<string, unknown>, ctx?: ToolExecuteContext) => Promise<unknown>;
 }
-export type ToolCallEvent = {
+export interface ToolCallEvent {
     type: 'tool-call';
     name: string;
     args: Record<string, unknown>;
     rawCall?: string | undefined;
     effect?: ToolEffect | undefined;
     display?: ToolCallDisplay | undefined;
-};
-export type ToolResultEvent = {
+}
+export interface ToolResultEvent {
     type: 'tool-result';
     name: string;
     result: unknown;
-};
-export type ToolActivityEvent = {
+}
+export interface ToolActivityEvent {
     type: 'tool-activity';
     name: string;
     args: Record<string, unknown>;
     resource: ResourceDescriptor | null;
     effect: ToolEffect;
     decision: ToolDecision;
-};
-export type ErrorEvent = {
+}
+export interface ErrorEvent {
     type: 'error';
     message: string;
-};
-export type AbortedEvent = {
+}
+export interface AbortedEvent {
     type: 'aborted';
-};
-export type MetricsEvent = {
+}
+export interface MetricsEvent {
     type: 'metrics';
     totalTokens: number;
     durationMs: number;
@@ -229,7 +230,7 @@ export type MetricsEvent = {
     route?: 'direct' | 'enhanced' | undefined;
     routeModel?: string | undefined;
     stopReason?: string | undefined;
-};
+}
 export interface InferenceCall {
     round: number;
     droppedTurns: number;
@@ -242,11 +243,11 @@ export interface InferenceCall {
     cacheKey: string | undefined;
     promptPrefix: string;
 }
-export type InferenceCallEvent = {
+export interface InferenceCallEvent {
     type: 'inference-call';
     call: InferenceCall;
-};
-export type InferenceSentEvent = {
+}
+export interface InferenceSentEvent {
     type: 'inference-sent';
     round: number;
     droppedTurns: number;
@@ -254,7 +255,7 @@ export type InferenceSentEvent = {
     tokens: InferenceTokens | undefined;
     outcome: 'completed' | 'overflowed' | 'failed';
     reason: string | undefined;
-};
+}
 export interface InferenceTokens {
     prompt?: number | undefined;
     generated?: number | undefined;