@qvac/harness 0.8.8 → 0.8.10

package/dist-lib/lib/log.js

@@ -1,31 +1,81 @@
+import QvacLogger, {} from '@qvac/logging';
+import { ENV_LOG_LEVEL, LEVEL_PRIORITIES } from '@qvac/logging/constants';
 import process from 'process';
-let enabled = process.env.QVAC_HARNESS_LOG === '1';
+const HOST_SCOPE = 'harness-client';
+let sink = null;
+let host = null;
+const logger = new QvacLogger({
+    level: 'debug',
+    error: writer('error'),
+    warn: writer('warn'),
+    info: writer('info'),
+    debug: writer('debug')
+});
+const fromEnv = envLevel();
+let configured = logger.getLevel();
+if (process.env.QVAC_HARNESS_LOG !== '1') {
+    logger.setLevel('off');
+}
+export const log = logger;
 export function setHarnessLog(on) {
-    enabled = on;
+    logger.setLevel(on ? configured : 'off');
 }
-export function harnessLogEnabled() {
-    return enabled;
+export function setHarnessLogLevel(level) {
+    logger.setLevel(level);
+}
+export function followHostLevel(level) {
+    configured = fromEnv ?? (isLogLevel(level) ? level : 'debug');
+    logger.setLevel(configured);
+}
+export function logToHost(next) {
+    host = next;
+    if (next) {
+        followHostLevel(next.getLevel?.());
+    }
+}
+export function harnessLogLevel() {
+    return logger.getLevel();
+}
+export function isLogLevel(value) {
+    return typeof value === 'string' && Object.hasOwn(LEVEL_PRIORITIES, value);
+}
+export function logEnabled(level) {
+    const current = logger.getLevel();
+    return current !== 'off' && LEVEL_PRIORITIES[level] <= LEVEL_PRIORITIES[current];
 }
-let sink = null;
 export function setHarnessLogSink(next) {
     sink = next;
 }
 export function hlog(message, data) {
-    if (!enabled)
-        return;
-    const tail = data === undefined ? '' : ` ${safeJson(data)}`;
-    const line = `${message}${tail}`;
-    if (sink) {
-        sink(line);
-        return;
-    }
-    process.stdout.write(`${line}\n`);
+    log.info(message, data);
 }
 export function hdiag(message, data) {
     if (!sink)
         return;
-    const tail = data === undefined ? '' : ` ${safeJson(data)}`;
-    sink(`${message}${tail}`);
+    sink(format(message, data), 'info');
+}
+function writer(level) {
+    return (message, data) => {
+        const line = format(message, data);
+        if (sink) {
+            sink(line, level);
+            return;
+        }
+        if (host) {
+            const write = host[level] ?? host.info;
+            write.call(host, HOST_SCOPE, line);
+            return;
+        }
+        process.stdout.write(`${line}\n`);
+    };
+}
+function envLevel() {
+    const value = process.env[ENV_LOG_LEVEL] || process.env[`EXPO_PUBLIC_${ENV_LOG_LEVEL}`];
+    const level = value?.toLowerCase();
+    return isLogLevel(level) ? level : null;
+}
+function format(message, data) {
+    return data === undefined ? message : `${message} ${safeJson(data)}`;
 }
 function safeJson(data) {
     try {

package/dist-lib/lib/models/model-pool.js

@@ -1,4 +1,5 @@
 import process from 'process';
+import { HarnessError } from '../errors.js';
 import { transferProgress } from '../model-download-progress.js';
 import ResourcePuddle from 'resource-puddle';
 import { ModelHandle } from './model-handle.js';
@@ -6,7 +7,7 @@ import { defaultContextSize } from './context.js';
 import { customContextLength } from './model-catalog.js';
 import { adrenoSafeKvCache } from './kv-cache.js';
 import { DEFAULT_EMBED_BATCH_SIZE } from './embed-config.js';
-import { hlog } from '../log.js';
+import { log } from '../log.js';
 import { RUNAWAY_STOP_SEQUENCES } from '../helpers/control-tokens.js';
 import { raceTimeout } from '../helpers/race-timeout.js';
 import { resolveModelSrc } from './model-source.js';
@@ -330,7 +331,7 @@ export function loadClockGuard(model, sdk, { now = () => Date.now(), monoMs = mo
         const mono = monoMs();
         if (wall - lastWall < mono - lastMono - jumpMs) {
             abandoned = true;
-            fail(new Error(`model load abandoned: system clock moved backward mid-load: ${model}`));
+            fail(new HarnessError('MODEL_LOAD_CLOCK_SKEW', [model]));
             return;
         }
         lastWall = wall;
@@ -393,7 +394,7 @@ export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = cr
             (chooseContext ? await chooseContext({ ...pending, modelConfig: config }, tier) : tier);
         const modelConfig = { ...config, ctx_size: ctxSize };
         const { projectionModelSrc: projection, ...loggedConfig } = modelConfig;
-        hlog('llm load config', { model, projection: Boolean(projection), ...loggedConfig });
+        log.debug('llm load config', { model, projection: Boolean(projection), ...loggedConfig });
         const admission = await beforeLoad?.({ ...pending, modelConfig });
         const loadStarted = Date.now();
         const modelId = await loadClockGuard(model, sdk)
@@ -404,7 +405,7 @@ export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = cr
             onProgress: (progress) => notify(progressState(model, progress))
         })))
             .finally(() => admission?.release());
-        hlog('llm loaded', { model, loadMs: Date.now() - loadStarted });
+        log.info('llm loaded', { model, loadMs: Date.now() - loadStarted });
         return { model, modelId, ctxSize, bytes: admission?.bytes };
     };
     return new ModelPuddle({
@@ -476,7 +477,11 @@ export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig
             .race(attempt().catch((err) => {
             if (!wantsGpu || gpuRefused || loads.draining)
                 throw err;
-            hlog('voice gpu load refused, retrying on cpu', { model, modelType, error: String(err) });
+            log.warn('voice gpu load refused, retrying on cpu', {
+                model,
+                modelType,
+                error: String(err)
+            });
             gpuRefused = true;
             return attempt();
         }))
@@ -510,7 +515,7 @@ function unloadOnGc(loadSdk, notify) {
                 await sdk.unloadModel({ modelId });
             }
             catch (err) {
-                hlog('unload failed', { model, err: errorMessage(err) });
+                log.warn('unload failed', { model, err: errorMessage(err) });
                 continue;
             }
             notify({ status: 'unloaded', model, catalogChanged: true });

package/dist-lib/lib/models/model-source.js

@@ -1,3 +1,4 @@
+import { HarnessError } from '../errors.js';
 import { audioGenModelByName, curatedModelAsset, customModelSrc } from './model-catalog.js';
 export async function resolveModelSrc(sdk, model, addon = 'llm') {
     if (/^(\/|~|\.|file:|https?:|registry:|pear:|hyper:)/.test(model)) {
@@ -10,7 +11,7 @@ export async function resolveModelSrc(sdk, model, addon = 'llm') {
     if (addon === 'audiogen') {
         const audio = audioGenModelByName(model);
         if (!audio) {
-            throw new Error(`audiogen model not found: ${model}`);
+            throw new HarnessError('AUDIOGEN_MODEL_NOT_FOUND', [model]);
         }
         return audio.src;
     }
@@ -20,7 +21,7 @@ export async function resolveModelSrc(sdk, model, addon = 'llm') {
     }
     const [entry] = await sdk.modelRegistrySearch({ filter: model, addon });
     if (!entry) {
-        throw new Error(`model not found in registry: ${model} (addon=${addon})`);
+        throw new HarnessError('MODEL_NOT_IN_REGISTRY', [model, addon]);
     }
     return { ...entry, src: `registry://${entry.registrySource}/${entry.registryPath}` };
 }

package/dist-lib/lib/no-redirect-fetch-bare.js

@@ -1,6 +1,7 @@
 import http, { Agent as HttpAgent } from 'bare-http1';
 import https, { Agent as HttpsAgent } from 'bare-https';
 import * as bareDns from 'bare-dns';
+import { HarnessError } from './errors.js';
 import { isPrivateOrBlocked } from './tools/private-ip.js';
 import { makeValidatingLookup } from './validating-lookup.js';
 import { runNoRedirectFetch } from './no-redirect-fetch-impl.js';
@@ -55,5 +56,5 @@ function readMethod(method) {
         method === 'OPTIONS') {
         return method;
     }
-    throw new Error(`unsupported HTTP method: ${method}`);
+    throw new HarnessError('UNSUPPORTED_HTTP_METHOD', [method]);
 }

package/dist-lib/lib/no-redirect-fetch-impl.js

@@ -1,4 +1,5 @@
 import b4a from 'b4a';
+import { HarnessError } from './errors.js';
 import { DEFAULT_USER_AGENT } from './user-agent.js';
 const UA_SNIFFING_HOSTS = new Set(['wttr.in']);
 export function runNoRedirectFetch(request, url, init = {}) {
@@ -55,7 +56,7 @@ export function runNoRedirectFetch(request, url, init = {}) {
                         req.destroy();
                         return;
                     }
-                    const err = new Error(`response exceeded ${init.maxBytes} bytes`);
+                    const err = new HarnessError('RESPONSE_TOO_LARGE', [init.maxBytes]);
                     req.destroy(err);
                     fail(err);
                     return;

package/dist-lib/lib/office/extract.js

@@ -1,17 +1,18 @@
+import { HarnessError } from '../errors.js';
 import { errorMessage } from '../guards.js';
 const MAX_OFFICE_BYTES = 20 * 1024 * 1024;
 export function extractWith(bytes, { fileName, signal, extract }) {
     if (bytes.byteLength > MAX_OFFICE_BYTES) {
-        throw new Error(`document is too large to extract: ${bytes.byteLength} bytes, limit ${MAX_OFFICE_BYTES}`);
+        throw new HarnessError('OFFICE_TOO_LARGE', [bytes.byteLength, MAX_OFFICE_BYTES]);
     }
     if (signal?.aborted) {
-        throw new Error(`${fileName}: extraction aborted`);
+        throw new HarnessError('OFFICE_EXTRACTION_ABORTED', [fileName]);
     }
     try {
         return extract(bytes);
     }
     catch (err) {
-        throw new Error(`${fileName}: ${errorMessage(err)}`);
+        throw new HarnessError('OFFICE_EXTRACTION_FAILED', [fileName, errorMessage(err)]);
     }
 }
 export function cellText(value) {

package/dist-lib/lib/office/index.js

@@ -1,4 +1,5 @@
 import path from 'path';
+import { HarnessError } from '../errors.js';
 import { extractDocxText } from '../docx/index.js';
 import { pptx, xlsx } from './engine/index.js';
 import { cellText, extractWith } from './extract.js';
@@ -89,5 +90,5 @@ export async function extractOfficeText(bytes, fileName, options = {}) {
     if (extract) {
         return extractWith(bytes, { fileName, signal: options.signal, extract });
     }
-    throw new Error(`Unsupported Office document: ${fileName}`);
+    throw new HarnessError('OFFICE_UNSUPPORTED_DOCUMENT', [fileName]);
 }

package/dist-lib/lib/resolution-detector.js

@@ -1,5 +1,5 @@
 import { errorMessage, isRecord } from './guards.js';
-import { hlog } from './log.js';
+import { log } from './log.js';
 function readValue(value, key) {
     if (value === null)
         return undefined;
@@ -80,7 +80,7 @@ export function installResolutionDetector(meta) {
     const wrapped = (specifier, parentURL, opts = {}) => {
         const parent = String(parentURL);
         if (isReferrerLost(opts.referrer, parent, cacheRecord)) {
-            hlog('diag referrer LOST', {
+            log.warn('diag referrer LOST', {
                 specifier,
                 parent,
                 modules: Object.keys(cacheRecord).length,
@@ -92,7 +92,7 @@ export function installResolutionDetector(meta) {
         }
         catch (err) {
             if (isReferrerLost(opts.referrer, parent, cacheRecord)) {
-                hlog('diag resolve FAILED after a lost referrer', resolutionFailure(specifier, parent, err));
+                log.error('diag resolve FAILED after a lost referrer', resolutionFailure(specifier, parent, err));
             }
             throw err;
         }

package/dist-lib/lib/rpc-session.js

@@ -1,8 +1,9 @@
+import { HarnessError } from './errors.js';
 export function settleOnClose(hrpc) {
     const session = hrpc;
     let reason = null;
     const dead = (err) => {
-        reason ??= err ?? new Error('rpc stream destroyed');
+        reason ??= err ?? new HarnessError('RPC_STREAM_DESTROYED');
     };
     const call = session._call.bind(session);
     const callSync = session._callSync.bind(session);

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

@@ -1,6 +1,6 @@
 import { errorMessage } from './guards.js';
 import { retryMemo } from './helpers/retry-memo.js';
-import { hlog } from './log.js';
+import { log } from './log.js';
 const defaultImports = {
     sdk: () => import('#sdk'),
     plugins: () => import('@qvac/sdk/plugins'),
@@ -14,7 +14,7 @@ function register(registry, name, plugin) {
         registry.registerPlugin(plugin);
     }
     catch (err) {
-        hlog('plugin registration skipped', {
+        log.warn('plugin registration skipped', {
             plugin: name,
             err: errorMessage(err)
         });

package/dist-lib/lib/serve.js

@@ -1,6 +1,7 @@
 import { AbortController } from 'bare-abort-controller';
 import b4a from 'b4a';
 import fs from 'fs';
+import { HarnessError } from './errors.js';
 import { settleOnClose } from './rpc-session.js';
 import { pipeline, Readable } from 'streamx';
 import { bindApi } from '../spec/bind.js';
@@ -9,7 +10,7 @@ import { isCapability } from './capabilities/invoke.js';
 import { CUSTOM_TASK_TYPES } from './models/model-catalog.js';
 import { unsupportedKvCacheDeletion } from './capabilities/kv-cache.js';
 import { errorMessage, isRecord } from './guards.js';
-import { hlog } from './log.js';
+import { log } from './log.js';
 import { pushQueue } from './queue.js';
 import { TextCoalescer } from './helpers/text-coalescer.js';
 import { prepareOpenclCache } from './models/opencl-cache.js';
@@ -57,7 +58,7 @@ export function serveHarness(stream, harness) {
         },
         memoryUsage: async () => {
             if (!harness.memoryUsage) {
-                throw new Error('harness does not support memoryUsage');
+                throw new HarnessError('CAPABILITY_UNSUPPORTED', ['memoryUsage']);
             }
             return harness.memoryUsage();
         },
@@ -109,7 +110,7 @@ export function serveHarness(stream, harness) {
         },
         previewModelSource: async ({ src, mmprojSrc }) => {
             if (!harness.previewModelSource) {
-                throw new Error('harness does not support previewModelSource');
+                throw new HarnessError('CAPABILITY_UNSUPPORTED', ['previewModelSource']);
             }
             return harness.previewModelSource({ src: src ?? '', mmprojSrc: mmprojSrc ?? undefined });
         },
@@ -127,13 +128,14 @@ export function serveHarness(stream, harness) {
             skills: []
         },
         embed: async ({ model, texts }) => {
-            if (!harness.embed)
-                throw new Error('harness does not support embed');
+            if (!harness.embed) {
+                throw new HarnessError('CAPABILITY_UNSUPPORTED', ['embed']);
+            }
             return packVectors(await harness.embed({ model, texts: texts ?? [] }));
         },
         transcribe: async ({ model, audio }) => {
             if (!harness.transcribe) {
-                throw new Error('harness does not support transcribe');
+                throw new HarnessError('CAPABILITY_UNSUPPORTED', ['transcribe']);
             }
             return {
                 text: await harness.transcribe({ model: model ?? '', audio: audio ?? b4a.alloc(0) })
@@ -141,7 +143,7 @@ export function serveHarness(stream, harness) {
         },
         detectLanguage: async ({ text, topK }) => {
             if (!harness.detectLanguage) {
-                throw new Error('harness does not support detectLanguage');
+                throw new HarnessError('CAPABILITY_UNSUPPORTED', ['detectLanguage']);
             }
             const languages = await harness.detectLanguage({
                 text: text ?? '',
@@ -150,8 +152,9 @@ export function serveHarness(stream, harness) {
             return { languages };
         },
         speak: async ({ model, text }) => {
-            if (!harness.speak)
-                throw new Error('harness does not support speak');
+            if (!harness.speak) {
+                throw new HarnessError('CAPABILITY_UNSUPPORTED', ['speak']);
+            }
             return harness.speak({ model: model ?? '', text: text ?? '' });
         },
         speakStream: speakStream(harness),
@@ -195,26 +198,26 @@ export function serveHarness(stream, harness) {
         }),
         capability: async () => {
             if (!harness.capability) {
-                throw new Error('harness does not support capability');
+                throw new HarnessError('CAPABILITY_UNSUPPORTED', ['capability']);
             }
             return harness.capability();
         },
         warmModel: async ({ model, agent }) => {
             if (!harness.warmModel) {
-                throw new Error('harness does not support warmModel');
+                throw new HarnessError('CAPABILITY_UNSUPPORTED', ['warmModel']);
             }
             await harness.warmModel({ model, agent: agent ?? {} });
             return { ok: true };
         },
         loadModel: async ({ model, agent }) => {
             if (!harness.loadModel) {
-                throw new Error('harness does not support loadModel');
+                throw new HarnessError('CAPABILITY_UNSUPPORTED', ['loadModel']);
             }
             return harness.loadModel({ model, agent: agent ?? {} });
         },
         unloadModel: async ({ model }) => {
             if (!harness.unloadModel) {
-                throw new Error('harness does not support unloadModel');
+                throw new HarnessError('CAPABILITY_UNSUPPORTED', ['unloadModel']);
             }
             return harness.unloadModel({ model });
         },
@@ -255,7 +258,7 @@ function toWireSkill(skill) {
     };
 }
 function unsupportedEmbeddingDeviceControl() {
-    return new Error('harness does not support embedding device control');
+    return new HarnessError('CAPABILITY_UNSUPPORTED', ['embedding device control']);
 }
 function modelEvents(harness) {
     let last = '';
@@ -328,7 +331,7 @@ function modelEvents(harness) {
 function speakStream(harness) {
     return async function* (duplex) {
         if (!harness.speakStream) {
-            throw new Error('harness does not support speakStream');
+            throw new HarnessError('CAPABILITY_UNSUPPORTED', ['speakStream']);
         }
         const text = pushQueue();
         const end = () => text.end();
@@ -349,11 +352,12 @@ function runFrame(harness, frame, context) {
     if (frame.type !== 'invoke') {
         return harness.completion(context);
     }
-    if (!harness.invoke)
-        throw new Error('harness does not support invoke');
+    if (!harness.invoke) {
+        throw new HarnessError('CAPABILITY_UNSUPPORTED', ['invoke']);
+    }
     const capability = frame.capability ?? '';
     if (!isCapability(capability)) {
-        throw new Error(`unknown capability: ${capability}`);
+        throw new HarnessError('UNKNOWN_CAPABILITY', [capability]);
     }
     return harness.invoke({
         capability,
@@ -386,15 +390,15 @@ function completion(harness) {
             pending.clear();
             for (const { reject, staged } of pendingAttach.values()) {
                 void fs.promises.unlink(staged).catch(noop);
-                reject(new Error('client gone'));
+                reject(new HarnessError('CLIENT_GONE'));
             }
             pendingAttach.clear();
             for (const { reject } of pendingFetch.values()) {
-                reject(new Error('client gone'));
+                reject(new HarnessError('CLIENT_GONE'));
             }
             pendingFetch.clear();
             for (const { reject } of pendingRag.values()) {
-                reject(new Error('client gone'));
+                reject(new HarnessError('CLIENT_GONE'));
             }
             pendingRag.clear();
             for (const { resolve } of pendingQuestion.values()) {
@@ -405,7 +409,7 @@ function completion(harness) {
                 if (path) {
                     void fs.promises.unlink(path).catch(noop);
                 }
-                reject(new Error('client gone'));
+                reject(new HarnessError('CLIENT_GONE'));
             }
             pendingDrive.clear();
             events.end();
@@ -498,7 +502,7 @@ function completion(harness) {
                     return;
                 }
                 if (frame.message) {
-                    hlog('question failed', { callId: frame.callId, message: frame.message });
+                    log.warn('question failed', { callId: frame.callId, message: frame.message });
                 }
                 waiter.resolve(frame.answer || null);
                 return;
@@ -551,7 +555,7 @@ function completion(harness) {
                     : undefined,
                 driveOp: frame.grantedDrives?.length
                     ? (request) => controller.signal.aborted
-                        ? Promise.reject(new Error('client gone'))
+                        ? Promise.reject(new HarnessError('CLIENT_GONE'))
                         : new Promise((resolve, reject) => {
                             const callId = String(calls++);
                             pendingDrive.set(callId, {
@@ -582,7 +586,7 @@ function completion(harness) {
                     const staged = await stageFile('attach', input.bytes);
                     if (controller.signal.aborted) {
                         void fs.promises.unlink(staged).catch(noop);
-                        throw new Error('client gone');
+                        throw new HarnessError('CLIENT_GONE');
                     }
                     return new Promise((resolve, reject) => {
                         const callId = String(calls++);
@@ -598,7 +602,7 @@ function completion(harness) {
                     });
                 },
                 fetchAttachment: ({ attachmentId, meta } = {}) => controller.signal.aborted
-                    ? Promise.reject(new Error('client gone'))
+                    ? Promise.reject(new HarnessError('CLIENT_GONE'))
                     : new Promise((resolve, reject) => {
                         const callId = String(calls++);
                         pendingFetch.set(callId, { resolve, reject });
@@ -610,7 +614,7 @@ function completion(harness) {
                         });
                     }),
                 ragSearch: ({ query, limit }) => controller.signal.aborted
-                    ? Promise.reject(new Error('client gone'))
+                    ? Promise.reject(new HarnessError('CLIENT_GONE'))
                     : new Promise((resolve, reject) => {
                         const callId = String(calls++);
                         pendingRag.set(callId, { resolve, reject });
@@ -660,7 +664,7 @@ function completion(harness) {
                     events.push({ type: 'error', message: errorMessage(err) });
                 }
                 events.push({ type: 'done' });
-                hlog('wire end', { produced, frames });
+                log.debug('wire end', { produced, frames });
                 events.end();
             })();
         });
@@ -668,7 +672,7 @@ function completion(harness) {
             yield event;
             await tick();
         }
-        hlog('wire handed off');
+        log.info('wire handed off');
     };
 }
 function downloadStream(harness, req) {

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

@@ -2,6 +2,7 @@ import type { SdkStorage } from './storage.ts';
 import { type StowIpc, type StowRunner } from 'bare-supervisor/stow';
 import type { ChildSpec } from 'bare-supervisor';
 import { type RemoteHarness } from './connect.ts';
+import { type HostLogger } from './log.ts';
 import { type EmbedDevice } from './models/embed-config.ts';
 import type { ImageClamps } from './models/model-catalog.ts';
 import type { ImageModelSet } from './tools/generate-image.ts';
@@ -10,10 +11,7 @@ export type MusicModelArg = string | (MusicModelStages & {
     inferenceSteps?: number;
     useGpu?: boolean;
 });
-export interface Logger {
-    info(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-}
+export type Logger = HostLogger;
 export interface HarnessLlmConfig {
     llmDevice?: 'cpu' | 'gpu';
     llmGpuLayers?: number;

package/dist-lib/lib/spawn.js

@@ -1,10 +1,11 @@
+import { HarnessError } from './errors.js';
 import stowChild, {} from 'bare-supervisor/stow';
 import { connectHarness } from './connect.js';
-import { setHarnessLog } from './log.js';
+import { isLogLevel, logToHost } from './log.js';
 import { createEmbedConfig } from './models/embed-config.js';
 export function harnessChild(entry, opts) {
     if (opts.logger) {
-        setHarnessLog(true);
+        logToHost(opts.logger);
     }
     const { runner, skillsDir, gpuStats, wheelsDir, sdkStorage, embedDevice, embedGpuLayers, embedBatchSize, imageModel, imageClamps, musicModel, musicClamps, llm, onIpc, logger = null, ...spec } = opts;
     const embedConfig = createEmbedConfig({
@@ -21,7 +22,7 @@ export function harnessChild(entry, opts) {
             JSON.stringify(embedConfig),
             imageModel ? JSON.stringify(imageModel) : '',
             imageClamps ? JSON.stringify(imageClamps) : '',
-            logger ? '1' : '',
+            logSlot(logger),
             llm ? JSON.stringify(llm) : '',
             musicModel ? JSON.stringify(musicModel) : '',
             musicClamps ? JSON.stringify(musicClamps) : '',
@@ -38,7 +39,7 @@ export function harnessChild(entry, opts) {
 export function spawnHarness(opts) {
     const logger = opts.logger ?? null;
     if (logger) {
-        setHarnessLog(true);
+        logToHost(logger);
     }
     const embedConfig = createEmbedConfig({
         device: opts.embedDevice,
@@ -53,18 +54,24 @@ export function spawnHarness(opts) {
             JSON.stringify(embedConfig),
             opts.imageModel ? JSON.stringify(opts.imageModel) : '',
             opts.imageClamps ? JSON.stringify(opts.imageClamps) : '',
-            logger ? '1' : '',
+            logSlot(logger),
             opts.llm ? JSON.stringify(opts.llm) : '',
             opts.musicModel ? JSON.stringify(opts.musicModel) : '',
             opts.musicClamps ? JSON.stringify(opts.musicClamps) : '',
             opts.wheelsDir ?? '',
             opts.gpuStats === undefined ? '' : JSON.stringify(opts.gpuStats)
         ], logger);
-        const died = exit.then((code) => `harness exited (${code}) before ready`);
+        const died = exit.then((code) => new HarnessError('HARNESS_EXITED_BEFORE_READY', [code]));
         const failure = await Promise.race([ipc.ready.then(() => null), died]);
         if (failure) {
-            throw new Error(failure);
+            throw failure;
         }
         return ipc;
     });
 }
+function logSlot(logger) {
+    if (!logger)
+        return '';
+    const level = logger.getLevel?.();
+    return isLogLevel(level) ? level : '1';
+}

package/dist-lib/lib/tools/edit-image.js

@@ -1,6 +1,7 @@
 import b4a from 'b4a';
 import fs from 'fs';
 import path from 'path';
+import { isHarnessError } from '../errors.js';
 import { AbortedError } from '../helpers/race-abort.js';
 import { BUSY_ERROR, DIM_STEP, effectiveSteps, generationPercentTick, IMAGE_LOAD_STALL_ERROR, normalizeClamps, parseCommonArgs, runDiffusion } from './generate-image.js';
 const DEFAULT_STRENGTH = 0.7;
@@ -278,7 +279,7 @@ export function createEditImageTool(runtime, { loadMedia = defaultLoadMedia, res
                 if (err instanceof AbortedError) {
                     return { error: 'image generation canceled' };
                 }
-                if (err instanceof Error && err.message === IMAGE_LOAD_STALL_ERROR) {
+                if (isHarnessError(err, 'IMAGE_LOAD_STALLED')) {
                     return { error: IMAGE_LOAD_STALL_ERROR };
                 }
                 throw err;