@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

package/dist-lib/lib/run-log/run-journal.js

@@ -1,12 +1,14 @@
 import xstatePkg from 'xstate/package.json' with { type: 'json' };
-import { AbortedError, RecoveryRequired } from '../machine/errors.js';
+import { RequestDecoder, RequestEncoder, requestRecord } from './request-codec.js';
+import { CompletionMachine } from '../machine/index.js';
+import { AbortedError, RecoveryRequired } from '../helpers/engine-error.js';
 import { errorMessage, isRecord } from '../guards.js';
 import { apply, diff } from './patch.js';
-import { stableStringify } from '../machine/stable-stringify.js';
-import { compactMachineEvent, compactSnapshotHistory, materializeMachineEvent, materializeSnapshotHistory, FAILURE_RESULT_REF_MACHINE_VERSION, snapshotFailureResultRefs, requestMessages, validateHistoryProjection, validateSnapshotHistory } from './history-codec.js';
+import { stableStringify } from '../helpers/stable-stringify.js';
+import { copy } from '../helpers/copy.js';
+import { compactMachineEvent, compactSnapshotHistory, materializeMachineEvent, materializeSnapshotHistory, snapshotFailureResultRefs, requestMessages, validateHistoryProjection, validateSnapshotHistory } from './history-codec.js';
 import { RUN_LOG_VERSION, applyEngineStep, brandCapturedRecord, buildEngineBoot, createEngineBoot, prepareEngineBoot, captureRunRecord, InvalidEngineStep, isCapturedJson, validateEngineBoot, pendingCallNames, pendingCallArgs, pendingToolArgs, unsettledRedactedIds } from './protocol.js';
 export { RUN_LOG_VERSION, RecoveryRequired, pendingCallNames, pendingToolArgs, unsettledRedactedIds };
-export const MACHINE_VERSION = 12;
 export const XSTATE_VERSION = xstatePkg.version;
 function compatibleXStateVersion(found) {
     if (found === null)
@@ -34,11 +36,6 @@ export class RunIncompatible extends Error {
         this.kind = opts.kind;
     }
 }
-export function copy(value) {
-    if (value === undefined)
-        return value;
-    return JSON.parse(JSON.stringify(value));
-}
 function pendingWriteReceipts(receipts) {
     return [...receipts].filter((receipt) => receipt.effect === 'write' && receipt.status !== 'result' && !receipt.name.startsWith('hook:'));
 }
@@ -106,7 +103,14 @@ export function recoveryAdvice(ids, receipts, redactedPendingIds) {
     }
     return clauses.join('; ');
 }
-const RUN_RECORD_TYPES = new Set(['metadata', 'checkpoint', 'delta', 'operation', 'fork']);
+const RUN_RECORD_TYPES = new Set([
+    'metadata',
+    'checkpoint',
+    'delta',
+    'operation',
+    'fork',
+    'request'
+]);
 function readBoundaryBoot(core) {
     const candidate = Reflect.get(core, ENGINE_BOUNDARY_BOOT);
     if (typeof candidate !== 'function') {
@@ -120,15 +124,14 @@ function eventRecord(value) {
     }
     return value;
 }
-function inspectionRecord(value, sourceVersion) {
+function inspectionRecord(value) {
     if (!isRecord(value)) {
         throw new InvalidEngineStep('Malformed run record');
     }
     if (typeof value.type !== 'string' || !RUN_RECORD_TYPES.has(value.type)) {
         throw new Error(`Unknown run-log record type: ${String(value.type)}`);
     }
-    const normalized = sourceVersion === RUN_LOG_VERSION ? value : { ...value, version: RUN_LOG_VERSION };
-    return captureRunRecord(normalized);
+    return captureRunRecord(value);
 }
 export class RunJournal {
     snapshotSavedAt;
@@ -143,6 +146,7 @@ export class RunJournal {
     receipts = new Map();
     intentArgs = new Map();
     tail = Promise.resolve();
+    requests = new RequestEncoder();
     settledTail = this.tail;
     uncertainWrite() {
         for (const receipt of this.receipts.values()) {
@@ -165,6 +169,7 @@ export class RunJournal {
     hasRedactionProvenance;
     initialBoot;
     engineBoot;
+    compactedSnapshot;
     get snapshot() {
         return materializeSnapshotHistory(this.engineBoot.snapshot, requestMessages(this.engineBoot.metadata?.request));
     }
@@ -172,7 +177,8 @@ export class RunJournal {
         return requestMessages(this.engineBoot.metadata?.request);
     }
     compactSnapshot(snapshot) {
-        const compacted = compactSnapshotHistory(snapshot, this.requestHistoryBase);
+        const compacted = compactSnapshotHistory(snapshot, this.requestHistoryBase, this.compactedSnapshot);
+        this.compactedSnapshot = snapshot;
         return isCapturedJson(snapshot) ? brandCapturedRecord(compacted) : compacted;
     }
     constructor(core, opts = {}) {
@@ -241,32 +247,24 @@ export class RunJournal {
         if (!boot.metadata) {
             return;
         }
-        if (boot.machineVersion === MACHINE_VERSION) {
-            const base = requestMessages(boot.metadata.request);
-            const allowLegacyFailureResults = this.allowLegacyFailureResults(boot);
-            if (boot.snapshot !== undefined) {
-                validateSnapshotHistory(boot.snapshot, base, {
-                    allowLegacyInlineFailureResults: allowLegacyFailureResults
-                });
-            }
-            if (boot.eventState !== null) {
-                validateHistoryProjection(boot.eventState, {
-                    base,
-                    failureRefs: boot.snapshot === undefined
-                        ? new Set()
-                        : snapshotFailureResultRefs(boot.snapshot, allowLegacyFailureResults),
-                    validateFailureOutputs: !allowLegacyFailureResults
-                });
-            }
-        }
-        if (boot.machineVersion !== MACHINE_VERSION) {
+        if (boot.machineVersion !== CompletionMachine.VERSION) {
             throw new RunIncompatible({
                 runId: boot.metadata.runId,
                 found: boot.machineVersion ?? -1,
-                expected: MACHINE_VERSION,
+                expected: CompletionMachine.VERSION,
                 kind: 'machine'
             });
         }
+        const base = requestMessages(boot.metadata.request);
+        if (boot.snapshot !== undefined) {
+            validateSnapshotHistory(boot.snapshot, base);
+        }
+        if (boot.eventState !== null) {
+            validateHistoryProjection(boot.eventState, {
+                base,
+                failureRefs: boot.snapshot === undefined ? new Set() : snapshotFailureResultRefs(boot.snapshot)
+            });
+        }
         if (!compatibleXStateVersion(boot.xstateVersion)) {
             throw new RunIncompatible({
                 runId: boot.metadata.runId,
@@ -276,9 +274,6 @@ export class RunJournal {
             });
         }
     }
-    allowLegacyFailureResults(boot) {
-        return (boot.machineVersion ?? 0) < FAILURE_RESULT_REF_MACHINE_VERSION;
-    }
     restoreBoot(boot) {
         this.engineBoot = prepareEngineBoot(boot);
         this.metadata = boot.metadata ? copy(boot.metadata) : undefined;
@@ -586,6 +581,13 @@ export class RunJournal {
             this.trackForkPoint(receipt);
         }
     }
+    async recordRequest(request) {
+        if (this.sealed)
+            throw new AbortedError();
+        const whole = this.redactShared(requestRecord(request));
+        const record = this.requests.encode(whole, this.requestHistoryBase);
+        await this.append(isCapturedJson(whole) ? brandCapturedRecord(record) : record);
+    }
     async operation(operation, execute, facts, signal) {
         if (this.sealed)
             throw new AbortedError();
@@ -706,17 +708,11 @@ export class EventCodec {
         this.merge(copy(event));
         return eventRecord(materializeMachineEvent(event, this.historyBase));
     }
-    decodeLegacy(patch) {
-        const event = eventRecord(apply(copy(this.base), patch));
-        this.merge(copy(event));
-        return event;
-    }
     merge(event) {
-        for (const key of Object.keys(event)) {
-            const value = event[key];
+        for (const [key, value] of Object.entries(defined(event))) {
             const previous = Object.hasOwn(this.base, key) ? this.base[key] : undefined;
             Object.defineProperty(this.base, key, {
-                value: isRecord(value) && isRecord(previous) ? { ...previous, ...value } : value,
+                value: isObject(value) && isObject(previous) ? { ...previous, ...defined(value) } : value,
                 writable: true,
                 enumerable: true,
                 configurable: true
@@ -724,39 +720,43 @@ export class EventCodec {
         }
     }
 }
-export async function* readRunLog(core, opts = {}) {
-    await core.ready();
-    let boot = createEngineBoot();
-    let codec = new EventCodec();
-    for (let index = 0; index < core.length; index++) {
-        const raw = await core.get(index);
-        const sourceVersion = isRecord(raw) && typeof raw.version === 'number' ? raw.version : -1;
-        if (!isRecord(raw) ||
-            (sourceVersion !== RUN_LOG_VERSION &&
-                !(opts.legacyInspection === true && sourceVersion === 4))) {
+function defined(record) {
+    return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+function isObject(value) {
+    return isRecord(value) && !Array.isArray(value);
+}
+export class RunLogFold {
+    boot = createEngineBoot();
+    codec = new EventCodec();
+    anyMachine;
+    constructor(opts = {}) {
+        this.anyMachine = opts.anyMachine === true;
+    }
+    add(raw) {
+        const index = this.boot.length;
+        const found = isRecord(raw) && typeof raw.version === 'number' ? raw.version : -1;
+        if (found !== RUN_LOG_VERSION) {
             throw new RunIncompatible({
-                runId: boot.metadata?.runId,
-                found: sourceVersion,
+                runId: this.boot.metadata?.runId,
+                found,
                 expected: RUN_LOG_VERSION,
                 kind: 'log'
             });
         }
-        const record = inspectionRecord(raw, sourceVersion);
-        const foldable = sourceVersion === 4 && (record.type === 'checkpoint' || record.type === 'delta')
-            ? { ...record, events: [] }
-            : record;
-        const next = applyEngineStep(boot, {
-            seq: boot.nextSeq,
-            expectedLength: boot.length,
-            records: [foldable]
+        const record = inspectionRecord(raw);
+        const next = applyEngineStep(this.boot, {
+            seq: this.boot.nextSeq,
+            expectedLength: this.boot.length,
+            records: [record]
         });
         if (record.type === 'metadata') {
-            codec = new EventCodec(requestMessages(record.request));
-            if (record.machine !== MACHINE_VERSION && !opts.anyMachine) {
+            this.codec = new EventCodec(requestMessages(record.request));
+            if (record.machine !== CompletionMachine.VERSION && !this.anyMachine) {
                 throw new RunIncompatible({
                     runId: record.runId,
                     found: record.machine,
-                    expected: MACHINE_VERSION,
+                    expected: CompletionMachine.VERSION,
                     kind: 'machine'
                 });
             }
@@ -764,20 +764,45 @@ export async function* readRunLog(core, opts = {}) {
         let events = [];
         if (record.type === 'checkpoint' || record.type === 'delta') {
             if (record.reset) {
-                codec.reset();
+                this.codec.reset();
             }
-            events = (record.events ?? []).map((patch) => sourceVersion === 4 ? codec.decodeLegacy(patch) : codec.decode(patch));
+            events = (record.events ?? []).map((patch) => this.codec.decode(patch));
             if (record.type === 'checkpoint') {
-                codec.reset();
+                this.codec.reset();
             }
         }
-        boot = next;
-        yield {
+        this.boot = next;
+        return {
             index,
-            sourceVersion,
             record,
-            snapshot: materializeSnapshotHistory(boot.snapshot, requestMessages(boot.metadata?.request), boot.machineVersion !== null && boot.machineVersion < FAILURE_RESULT_REF_MACHINE_VERSION),
+            snapshot: materializeSnapshotHistory(this.boot.snapshot, requestMessages(this.boot.metadata?.request)),
             events
         };
     }
 }
+export async function* readRunLog(core, opts = {}) {
+    await core.ready();
+    const fold = new RunLogFold(opts);
+    for (let index = 0; index < core.length; index++) {
+        yield fold.add(await core.get(index));
+    }
+}
+export async function* readRequests(core) {
+    await core.ready();
+    let boot = createEngineBoot();
+    const decoder = new RequestDecoder();
+    for (let index = 0; index < core.length; index++) {
+        const record = captureRunRecord(await core.get(index));
+        boot = applyEngineStep(boot, {
+            seq: boot.nextSeq,
+            expectedLength: boot.length,
+            records: [record]
+        });
+        if (record.type !== 'request') {
+            continue;
+        }
+        const { round, attempt, droppedTurns } = record;
+        const params = decoder.decode(record, requestMessages(boot.metadata?.request));
+        yield { index, round, attempt, droppedTurns, params };
+    }
+}

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

@@ -1,3 +1,4 @@
+import type { AddonLoaders } from './contract/index.ts';
 type Sdk = typeof import('#sdk');
 export type SdkPlugin = Parameters<(typeof import('@qvac/sdk/plugins'))['registerPlugin']>[0];
 type Plugin = SdkPlugin;
@@ -13,18 +14,12 @@ export interface SdkImports {
     embeddings(): Promise<{
         embeddingsPlugin: Plugin;
     }>;
-    tts(): Promise<{
-        ttsPlugin: Plugin;
-    }>;
-    parakeet(): Promise<{
-        parakeetPlugin: Plugin;
-    }>;
 }
 export interface SdkLoader {
     load(): Promise<Sdk>;
     loadEmbed(): Promise<Sdk>;
-    loadVoice(): Promise<Sdk>;
     peek(): Promise<Sdk> | null;
+    addons?: AddonLoaders;
 }
 export declare function createSdkLoader(imports?: SdkImports): SdkLoader;
 export {};

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

@@ -5,9 +5,7 @@ const defaultImports = {
     sdk: () => import('#sdk'),
     plugins: () => import('@qvac/sdk/plugins'),
     llm: () => import('@qvac/sdk/llamacpp-completion/plugin'),
-    embeddings: () => import('@qvac/sdk/llamacpp-embedding/plugin'),
-    tts: () => import('@qvac/sdk/onnx-tts/plugin'),
-    parakeet: () => import('@qvac/sdk/parakeet-transcription/plugin')
+    embeddings: () => import('@qvac/sdk/llamacpp-embedding/plugin')
 };
 function register(registry, name, plugin) {
     try {
@@ -39,16 +37,11 @@ export function createSdkLoader(imports = defaultImports) {
         register(registry, 'embeddings', embeddingsPlugin);
         return sdk;
     });
-    const loadVoice = retryMemo(async () => {
-        const [sdk, { ttsPlugin }, { parakeetPlugin }, registry] = await Promise.all([
-            load(),
-            imports.tts(),
-            imports.parakeet(),
-            imports.plugins()
-        ]);
-        register(registry, 'tts', ttsPlugin);
-        register(registry, 'parakeet', parakeetPlugin);
-        return sdk;
-    });
-    return { load, loadEmbed, loadVoice, peek: () => load.peek() };
+    const addons = {
+        sdk: load,
+        embeddings: loadEmbed,
+        'llm-llamacpp': () => import('@qvac/llm-llamacpp/addonLogging'),
+        'embed-llamacpp': () => import('@qvac/embed-llamacpp/addonLogging')
+    };
+    return { load, loadEmbed, peek: () => load.peek(), addons };
 }

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

@@ -6,12 +6,14 @@ import { installSdkConfigLoader } from '#sdk-config-loader';
 import { SDK_HOME_ENV } from './storage.js';
 export const SDK_CONFIG_PATH_ENV = 'QVAC_CONFIG_PATH';
 export const OPENCL_CACHE_DIR_ENV = 'QVAC_OPENCL_CACHE_DIR';
+const FIT_STUB_BUDGET_MS = 10_000;
 export function configureSdkStorage(storage, channels = {}) {
     const { env = process.env, argv = isBareKit ? Bare.argv : null } = channels;
     installSdkConfigLoader();
     mkdirSync(storage.home, { recursive: true });
     const configPath = join(storage.home, 'qvac.config.json');
-    writeFileSync(configPath, `${JSON.stringify({ cacheDirectory: storage.models }, null, 2)}\n`);
+    const config = { cacheDirectory: storage.models, fitStubBudgetMs: FIT_STUB_BUDGET_MS };
+    writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
     const openclCacheDir = join(storage.home, 'opencl-cache');
     mkdirSync(openclCacheDir, { recursive: true });
     if (argv) {