@qvac/harness 0.4.0 → 0.5.0

package/dist-lib/lib/spawn.js

@@ -3,8 +3,9 @@ import { connectHarness } from './connect.js';
 import { setHarnessLog } from './log.js';
 import { createEmbedConfig } from './models/embed-config.js';
 export function harnessChild(entry, opts) {
-    if (opts.logger)
+    if (opts.logger) {
         setHarnessLog(true);
+    }
     const { runner, skillsDir, gpuStats, wheelsDir, sdkStorage, embedDevice, embedGpuLayers, embedBatchSize, imageModel, imageClamps, musicModel, musicClamps, llm, onIpc, logger = null, ...spec } = opts;
     const embedConfig = createEmbedConfig({
         device: embedDevice,
@@ -36,8 +37,9 @@ export function harnessChild(entry, opts) {
 }
 export function spawnHarness(opts) {
     const logger = opts.logger ?? null;
-    if (logger)
+    if (logger) {
         setHarnessLog(true);
+    }
     const embedConfig = createEmbedConfig({
         device: opts.embedDevice,
         gpuLayers: opts.embedGpuLayers,
@@ -45,7 +47,7 @@ export function spawnHarness(opts) {
     });
     return connectHarness(async () => {
         const { default: Sidecar } = await import('bare-sidecar');
-        const { wrap } = (await import('bare-stow/host'));
+        const { wrap } = await import('bare-stow/host');
         const sidecar = new Sidecar(opts.entry, [
             opts.skillsDir ?? '',
             JSON.stringify(opts.sdkStorage),
@@ -66,8 +68,9 @@ export function spawnHarness(opts) {
             sidecar.once('exit', (code) => resolve(`harness exited (${code}) before ready`));
         });
         const failure = await Promise.race([ipc.ready.then(() => null), died]);
-        if (failure)
+        if (failure) {
             throw new Error(failure);
+        }
         return ipc;
     });
 }

package/dist-lib/lib/tmp-path.d.ts

@@ -1,7 +1,8 @@
-export type UserTmpOptions = {
-    readonly readOwner?: () => {
-        uid: number;
-        username: string;
-    };
-};
+export interface TmpOwner {
+    uid: number;
+    username: string;
+}
+export interface UserTmpOptions {
+    readonly readOwner?: () => TmpOwner;
+}
 export declare function userTmpPath(name: string, opts?: UserTmpOptions): string;

package/dist-lib/lib/tool-call-display.d.ts

@@ -1,8 +1,8 @@
-export type ToolCallDisplay = {
+export interface ToolCallDisplay {
     readonly label: string;
     readonly description?: string;
     readonly iconEmoji?: string;
-};
+}
 export type ToolExecutionOutcome = {
     readonly kind: 'success';
 } | {

package/dist-lib/lib/tools/create-documents.js

@@ -1,19 +1,25 @@
 import { canonicalDenyRoots, defaultRealpath, resolveKey } from './fs/scope.js';
 import { writeText } from './fs/write.js';
+import { errorMessage } from '../guards.js';
 function documentRequests(raw) {
     if (!Array.isArray(raw) || raw.length === 0)
         return null;
     const documents = [];
     for (const entry of raw) {
-        const record = entry;
-        if (typeof record?.path !== 'string' || !record.path.trim())
+        if (!isDocumentRequest(entry))
             return null;
-        if (typeof record.content !== 'string')
-            return null;
-        documents.push({ path: record.path, content: record.content });
+        documents.push({ path: entry.path, content: entry.content });
     }
     return documents;
 }
+function isDocumentRequest(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    if (!('path' in value) || typeof value.path !== 'string' || !value.path.trim()) {
+        return false;
+    }
+    return 'content' in value && typeof value.content === 'string';
+}
 export function createCreateDocumentsTool({ realpath = defaultRealpath, deniedRoots } = {}) {
     return {
         name: 'create_documents',
@@ -48,8 +54,9 @@ export function createCreateDocumentsTool({ realpath = defaultRealpath, deniedRo
         },
         resource(args) {
             const documents = documentRequests(args.documents);
-            if (!documents)
+            if (!documents) {
                 return null;
+            }
             const bytes = documents.reduce((sum, doc) => sum + doc.content.length, 0);
             const first = documents[0];
             const suffix = documents.length > 1 ? ` (+${documents.length - 1} more)` : '';
@@ -58,13 +65,14 @@ export function createCreateDocumentsTool({ realpath = defaultRealpath, deniedRo
         async execute(rawArgs, ctx) {
             const roots = ctx?.fsWriteRoots ?? [];
             const documents = documentRequests(rawArgs.documents);
-            if (!documents)
+            if (!documents) {
                 return { error: 'documents must be a non-empty array of { path, content }' };
+            }
             const created = [];
             const failed = [];
             const deny = await canonicalDenyRoots(deniedRoots, realpath);
             for (const doc of documents) {
-                const resolved = await resolveKey(doc.path, roots, realpath, deny);
+                const resolved = await resolveKey(doc.path, roots, { realpath, deny });
                 if ('error' in resolved) {
                     failed.push({ path: doc.path, error: resolved.error });
                     continue;
@@ -78,10 +86,10 @@ export function createCreateDocumentsTool({ realpath = defaultRealpath, deniedRo
                     created.push(doc.path);
                 }
                 catch (err) {
-                    failed.push({ path: doc.path, error: err.message });
+                    failed.push({ path: doc.path, error: errorMessage(err) });
                 }
             }
-            return { created, ...(failed.length ? { failed } : {}) };
+            return { created, failed: failed.length ? failed : undefined };
         }
     };
 }

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

@@ -1,28 +1,36 @@
 import b4a from 'b4a';
 import { canonicalDenyRoots, defaultRealpath, resolveKey } from './fs/scope.js';
 import { writeText } from './fs/write.js';
+import { errorMessage } from '../guards.js';
 function editRequests(raw) {
     if (!Array.isArray(raw) || raw.length === 0)
         return null;
     const edits = [];
     for (const entry of raw) {
-        const record = entry;
-        if (typeof record?.path !== 'string' || !record.path.trim())
+        if (!isEditRequest(entry))
             return null;
-        if (typeof record.search !== 'string' || record.search.length === 0)
-            return null;
-        if (typeof record.replace !== 'string')
-            return null;
-        edits.push({ path: record.path, search: record.search, replace: record.replace });
+        edits.push({ path: entry.path, search: entry.search, replace: entry.replace });
     }
     return edits;
 }
+function isEditRequest(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    if (!('path' in value) || typeof value.path !== 'string' || !value.path.trim()) {
+        return false;
+    }
+    if (!('search' in value) || typeof value.search !== 'string' || !value.search) {
+        return false;
+    }
+    return 'replace' in value && typeof value.replace === 'string';
+}
 function applyEdits(content, edits) {
     let next = content;
     for (const edit of edits) {
         const first = next.indexOf(edit.search);
-        if (first === -1)
+        if (first === -1) {
             return { error: 'search text not found' };
+        }
         if (next.indexOf(edit.search, first + edit.search.length) !== -1) {
             return { error: 'search text is ambiguous (matches more than once)' };
         }
@@ -66,8 +74,9 @@ export function createEditDocumentsTool({ realpath = defaultRealpath, deniedRoot
         },
         resource(args) {
             const edits = editRequests(args.edits);
-            if (!edits)
+            if (!edits) {
                 return null;
+            }
             const paths = [...new Set(edits.map((edit) => edit.path))];
             const label = paths.slice(0, 3).join(', ');
             return {
@@ -78,8 +87,9 @@ export function createEditDocumentsTool({ realpath = defaultRealpath, deniedRoot
         async execute(rawArgs, ctx) {
             const roots = ctx?.fsWriteRoots ?? [];
             const edits = editRequests(rawArgs.edits);
-            if (!edits)
+            if (!edits) {
                 return { error: 'edits must be a non-empty array of { path, search, replace }' };
+            }
             const byPath = new Map();
             for (const edit of edits) {
                 const list = byPath.get(edit.path) ?? [];
@@ -90,7 +100,7 @@ export function createEditDocumentsTool({ realpath = defaultRealpath, deniedRoot
             const failed = [];
             const deny = await canonicalDenyRoots(deniedRoots, realpath);
             for (const [file, fileEdits] of byPath) {
-                const resolved = await resolveKey(file, roots, realpath, deny);
+                const resolved = await resolveKey(file, roots, { realpath, deny });
                 if ('error' in resolved) {
                     failed.push({ path: file, error: resolved.error });
                     continue;
@@ -113,10 +123,10 @@ export function createEditDocumentsTool({ realpath = defaultRealpath, deniedRoot
                     edited.push(file);
                 }
                 catch (err) {
-                    failed.push({ path: file, error: err.message });
+                    failed.push({ path: file, error: errorMessage(err) });
                 }
             }
-            return { edited, ...(failed.length ? { failed } : {}) };
+            return { edited, failed: failed.length ? failed : undefined };
         }
     };
 }

package/dist-lib/lib/tools/edit-image.d.ts

@@ -4,12 +4,12 @@ import { type DiffusionRuntime } from './generate-image.ts';
 interface Rgba {
     width: number;
     height: number;
-    data: Buffer;
+    data: Uint8Array;
     frames?: Rgba[];
 }
 interface Media {
     image: {
-        decode(input: Buffer, opts?: {
+        decode(input: Uint8Array, opts?: {
             maxFrames?: number;
         }): Promise<Rgba>;
         encode(rgba: Rgba, opts: {

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

@@ -1,3 +1,4 @@
+import b4a from 'b4a';
 import fs from 'fs';
 import path from 'path';
 import { AbortedError } from '../helpers/race-abort.js';
@@ -11,13 +12,14 @@ async function turnSources(turnImages) {
     const sources = [];
     for (const image of turnImages) {
         const bytes = await fs.promises.readFile(image.path).catch(toNull);
-        if (!bytes)
+        if (!bytes) {
             return { error: `could not read attached image ${path.basename(image.path)}` };
+        }
         sources.push({ bytes, fileName: path.basename(image.path) });
     }
     return sources;
 }
-async function resolveSources(fetchAttachment, ids, turnImages, signal) {
+async function resolveSources(fetchAttachment, { ids, turnImages, signal }) {
     if (!ids.length) {
         if (turnImages.length) {
             const sources = await turnSources(turnImages);
@@ -33,13 +35,16 @@ async function resolveSources(fetchAttachment, ids, turnImages, signal) {
     const missing = [];
     for (const id of ids) {
         const found = await fetchAttachment({ attachmentId: id, signal });
-        if (found && 'bytes' in found && found.bytes)
+        if (found && 'bytes' in found && found.bytes) {
             sources.push(found);
-        else
+        }
+        else {
             missing.push(id);
+        }
     }
-    if (!missing.length)
+    if (!missing.length) {
         return { sources };
+    }
     if (sources.length) {
         return {
             sources,
@@ -48,8 +53,9 @@ async function resolveSources(fetchAttachment, ids, turnImages, signal) {
     }
     if (turnImages.length) {
         const fallback = await turnSources(turnImages);
-        if ('error' in fallback)
+        if ('error' in fallback) {
             return fallback;
+        }
         return {
             sources: fallback,
             note: `ignored unknown attachment id(s) ${missing.join(', ')} — edited the image(s) from the user's latest message`
@@ -62,7 +68,7 @@ async function resolveSources(fetchAttachment, ids, turnImages, signal) {
 }
 async function defaultLoadMedia() {
     try {
-        return (await import('bare-media'));
+        return await import('bare-media');
     }
     catch {
         return null;
@@ -129,8 +135,9 @@ export function createEditImageTool(runtime, { loadMedia = defaultLoadMedia, res
         }),
         execute: async (args, ctx) => {
             const common = parseCommonArgs(args, cap.maxSteps);
-            if ('error' in common)
+            if ('error' in common) {
                 return common;
+            }
             let strength = DEFAULT_STRENGTH;
             if (args.strength !== undefined && args.strength !== null) {
                 strength = Number(args.strength);
@@ -144,15 +151,17 @@ export function createEditImageTool(runtime, { loadMedia = defaultLoadMedia, res
             const attachmentIds = [];
             if (Array.isArray(args.attachment_ids)) {
                 for (const id of args.attachment_ids) {
-                    if (typeof id === 'string' && id)
+                    if (typeof id === 'string' && id) {
                         attachmentIds.push(id);
+                    }
                 }
             }
             if (attachmentId && attachmentIds.length) {
                 return { error: 'pass attachment_id or attachment_ids, not both' };
             }
-            if (attachmentId)
+            if (attachmentId) {
                 attachmentIds.push(attachmentId);
+            }
             if (!ctx?.attach || !ctx.fetchAttachment) {
                 return { error: 'this device cannot edit chat images' };
             }
@@ -161,16 +170,24 @@ export function createEditImageTool(runtime, { loadMedia = defaultLoadMedia, res
             if (!attachmentIds.length && turnImages.length > 1 && !inContext) {
                 return { error: MULTI_SOURCE_UNSUPPORTED };
             }
-            const resolved = await resolveSources(ctx.fetchAttachment, attachmentIds, turnImages, ctx.signal);
-            if (ctx.signal?.aborted)
+            const resolved = await resolveSources(ctx.fetchAttachment, {
+                ids: attachmentIds,
+                turnImages,
+                signal: ctx.signal
+            });
+            if (ctx.signal?.aborted) {
                 return { error: 'image generation canceled' };
-            if ('error' in resolved)
+            }
+            if ('error' in resolved) {
                 return resolved;
+            }
             const { sources, note } = resolved;
-            if (sources.length > 1 && !inContext)
+            if (sources.length > 1 && !inContext) {
                 return { error: MULTI_SOURCE_UNSUPPORTED };
-            if (!runtime.acquire())
+            }
+            if (!runtime.acquire()) {
                 return { error: BUSY_ERROR, code: 'busy' };
+            }
             const report = ctx.progress;
             const onTick = report && generationPercentTick((percentage) => report({ percentage }), sources.length);
             try {
@@ -186,7 +203,7 @@ export function createEditImageTool(runtime, { loadMedia = defaultLoadMedia, res
                 for (const source of sources) {
                     let decoded;
                     try {
-                        decoded = await media.image.decode(Buffer.from(source.bytes), { maxFrames: 1 });
+                        decoded = await media.image.decode(b4a.from(source.bytes), { maxFrames: 1 });
                     }
                     catch {
                         return { error: `could not decode ${source.fileName} as an image` };
@@ -198,7 +215,7 @@ export function createEditImageTool(runtime, { loadMedia = defaultLoadMedia, res
                     const fitted = frame.width === fitWidth && frame.height === fitHeight
                         ? frame
                         : await resample(frame, fitWidth, fitHeight);
-                    inits.push(Buffer.from(await media.image.encode(fitted, { mimetype: 'image/png' })));
+                    inits.push(b4a.from(await media.image.encode(fitted, { mimetype: 'image/png' })));
                     if (!width) {
                         width = fitWidth;
                         height = fitHeight;
@@ -207,24 +224,30 @@ export function createEditImageTool(runtime, { loadMedia = defaultLoadMedia, res
                 const sdk = await runtime.loadSdk();
                 const { modelId } = await runtime.ensureLoaded(sdk, ctx.signal, ctx.image?.modelChoice);
                 const fusion = inits.length > 1;
-                const image = await runDiffusion(sdk, modelId, {
-                    prompt: common.prompt,
-                    width,
-                    height,
-                    steps: effectiveSteps(common.steps, ctx.image?.steps, stepsCap),
-                    seed: common.seed,
-                    negative_prompt: common.negativePrompt,
-                    ...(inContext
-                        ? {
-                            init_images: inits,
-                            auto_resize_ref_image: true,
-                            guidance: FLUX2_GUIDANCE,
-                            cfg_scale: FLUX2_CFG_SCALE
-                        }
-                        : { init_image: inits[0], strength })
-                }, ctx.signal, onTick);
-                if (!(image instanceof Uint8Array))
+                const image = await runDiffusion(sdk, {
+                    modelId,
+                    params: {
+                        prompt: common.prompt,
+                        width,
+                        height,
+                        steps: effectiveSteps(common.steps, ctx.image?.steps, stepsCap),
+                        seed: common.seed,
+                        negative_prompt: common.negativePrompt,
+                        ...(inContext
+                            ? {
+                                init_images: inits,
+                                auto_resize_ref_image: true,
+                                guidance: FLUX2_GUIDANCE,
+                                cfg_scale: FLUX2_CFG_SCALE
+                            }
+                            : { init_image: inits[0], strength })
+                    },
+                    signal: ctx.signal,
+                    onTick
+                });
+                if (!(image instanceof Uint8Array)) {
                     return image;
+                }
                 const record = await ctx.attach({
                     fileName: `edited-${Date.now()}.png`,
                     mimeType: 'image/png',
@@ -244,7 +267,7 @@ export function createEditImageTool(runtime, { loadMedia = defaultLoadMedia, res
                     ...(sources.length === 1 && sources[0].id
                         ? { sourceAttachmentId: sources[0].id }
                         : { sourceFileNames: sources.map((source) => source.fileName) }),
-                    ...(notes.length ? { note: notes.join('; ') } : {}),
+                    note: notes.length ? notes.join('; ') : undefined,
                     fileName: record.fileName,
                     byteLength: record.byteLength,
                     width,
@@ -252,8 +275,9 @@ export function createEditImageTool(runtime, { loadMedia = defaultLoadMedia, res
                 };
             }
             catch (err) {
-                if (err instanceof AbortedError)
+                if (err instanceof AbortedError) {
                     return { error: 'image generation canceled' };
+                }
                 if (err instanceof Error && err.message === IMAGE_LOAD_STALL_ERROR) {
                     return { error: IMAGE_LOAD_STALL_ERROR };
                 }

package/dist-lib/lib/tools/exec/adapters/adapter.d.ts

@@ -1,14 +1,14 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { AttachFn, FetchAttachmentFn, RunBudget, ToolDecision } from '../../../capabilities/completion.ts';
 import type { ExecResult } from '../runner.ts';
-export type ExecutionOptions = {
+export interface ExecutionOptions {
     readonly cwd?: string;
     readonly env?: Readonly<Record<string, string>>;
     readonly timeoutMs?: number;
     readonly maxOutputChars?: number;
     readonly signal?: BareAbortSignal;
-};
-export type ExecutionContext = {
+}
+export interface ExecutionContext {
     readonly attach?: AttachFn;
     readonly fetchAttachment?: FetchAttachmentFn;
     readonly turnImages?: readonly {
@@ -19,13 +19,13 @@ export type ExecutionContext = {
     readonly toolNames?: readonly string[];
     readonly approval?: ToolDecision;
     readonly confirmConnect?: (host: string) => Promise<boolean>;
-};
-export type ExecutionPlan = {
+}
+export interface ExecutionPlan {
     run(options: ExecutionOptions): Promise<ExecResult> | ExecResult;
-};
-export type ExecutionAdapter = {
+}
+export interface ExecutionAdapter {
     resolve(args: Record<string, unknown>, ctx?: ExecutionContext): ExecutionPlan | null;
-};
-export type FallbackExecutionAdapter = {
+}
+export interface FallbackExecutionAdapter {
     resolve(args: Record<string, unknown>, ctx?: ExecutionContext): ExecutionPlan;
-};
+}

package/dist-lib/lib/tools/exec/adapters/python/attachments.d.ts

@@ -1,26 +1,32 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { AttachFn, FetchAttachmentFn, RunBudget } from '../../../../capabilities/completion.ts';
 import type { ExecAttachment, RejectedOutput } from '../../runner.ts';
-export type ExecInput = {
+import { type ExecError } from './output-policy.ts';
+export interface ExecInput {
     readonly attachmentId?: string;
     readonly path: string;
-};
-export type StagedInput = {
+}
+export interface StagedInput {
     readonly path: string;
     readonly bytes: Uint8Array;
-};
-export declare function stageInputs(fetchAttachment: FetchAttachmentFn, inputs: readonly ExecInput[], opts?: {
+}
+export interface StageInputsOptions {
     turnImages?: readonly {
         path: string;
     }[];
     signal?: BareAbortSignal;
-}): Promise<{
+}
+export interface StagedInputs {
     files: readonly StagedInput[];
-} | {
-    error: string;
-}>;
-export declare function attachOutputs(attach: AttachFn, files: ReadonlyMap<string, Uint8Array>, declared: readonly string[], runBudget?: RunBudget): Promise<{
+}
+export declare function stageInputs(fetchAttachment: FetchAttachmentFn, inputs: readonly ExecInput[], opts?: StageInputsOptions): Promise<StagedInputs | ExecError>;
+export interface AttachOutputsOptions {
+    readonly declared: readonly string[];
+    readonly runBudget?: RunBudget | undefined;
+}
+export interface AttachedOutputs {
     attachments: readonly ExecAttachment[];
     missingOutputs: readonly string[];
     rejectedOutputs: readonly RejectedOutput[];
-}>;
+}
+export declare function attachOutputs(attach: AttachFn, files: ReadonlyMap<string, Uint8Array>, { declared, runBudget }: AttachOutputsOptions): Promise<AttachedOutputs>;