@qvac/harness 0.4.0 → 0.6.0

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>;

package/dist-lib/lib/tools/exec/adapters/python/attachments.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { errorMessage } from '../../../../guards.js';
 import { hlog } from '../../../../log.js';
 import { checkOutputBytes, MAX_INPUT_TOTAL_BYTES, RUN_OUTPUT_BUDGET_BYTES } from './output-policy.js';
 const STAGE_TIMEOUT_MS = 60_000;
@@ -15,8 +16,9 @@ function bounded(work, ms, message) {
         timer = setTimeout(() => reject(new Error(message)), ms);
     });
     return Promise.race([work, bound]).finally(() => {
-        if (timer)
+        if (timer) {
             clearTimeout(timer);
+        }
     });
 }
 function hasBytes(record) {
@@ -25,12 +27,13 @@ function hasBytes(record) {
 function byteLengthOf(record) {
     return hasBytes(record) ? record.bytes.byteLength : record.byteLength;
 }
-async function uploadedBytes(fetchAttachment, turnImages, index, signal) {
+async function uploadedBytes(fetchAttachment, index, { turnImages, signal }) {
     const image = turnImages[index];
     if (image) {
         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)}` };
+        }
         return bytes;
     }
     if (turnImages.length) {
@@ -38,13 +41,32 @@ async function uploadedBytes(fetchAttachment, turnImages, index, signal) {
             error: `the user's latest message has only ${turnImages.length} image(s) — one id-less input per uploaded image`
         };
     }
-    if (index > 0)
+    if (index > 0) {
         return { error: NO_UPLOAD_ERROR };
+    }
     const latest = await fetchAttachment({ signal });
-    if (!latest || !hasBytes(latest))
+    if (!latest || !hasBytes(latest)) {
         return { error: NO_UPLOAD_ERROR };
+    }
     return latest.bytes;
 }
+async function probeUpload(fetchAttachment, input, { index, turnImages, signal, deadline }) {
+    if (DOCUMENT_INPUT.test(input.path)) {
+        return { error: NO_DOCUMENT_ERROR };
+    }
+    const bytes = await bounded(uploadedBytes(fetchAttachment, index, { turnImages, signal }), deadline - Date.now(), STAGE_TIMEOUT_MESSAGE);
+    if ('error' in bytes) {
+        return bytes;
+    }
+    return { size: bytes.byteLength, bytes };
+}
+async function probeAttachment(fetchAttachment, id, { signal, deadline }) {
+    const head = await bounded(fetchAttachment({ attachmentId: id, meta: true, signal }), deadline - Date.now(), STAGE_TIMEOUT_MESSAGE);
+    if (!head) {
+        return { error: `attachment ${id} not found in this chat` };
+    }
+    return { size: byteLengthOf(head), bytes: hasBytes(head) ? head.bytes : null };
+}
 export async function stageInputs(fetchAttachment, inputs, opts = {}) {
     const { turnImages = [], signal } = opts;
     const files = inputs.map(() => null);
@@ -52,32 +74,21 @@ export async function stageInputs(fetchAttachment, inputs, opts = {}) {
     const deadline = Date.now() + STAGE_TIMEOUT_MS;
     let total = 0;
     let uploads = 0;
-    for (let i = 0; i < inputs.length; i++) {
-        const input = inputs[i];
+    for (const [i, input] of inputs.entries()) {
         const id = input.attachmentId;
         try {
-            if (id === undefined) {
-                if (DOCUMENT_INPUT.test(input.path))
-                    return { error: NO_DOCUMENT_ERROR };
-                const bytes = await bounded(uploadedBytes(fetchAttachment, turnImages, uploads++, signal), deadline - Date.now(), STAGE_TIMEOUT_MESSAGE);
-                if ('error' in bytes)
-                    return bytes;
-                total += bytes.byteLength;
-                if (total > MAX_INPUT_TOTAL_BYTES) {
-                    hlog('python: input attachments over budget; skipping blob download', {
-                        total,
-                        cap: MAX_INPUT_TOTAL_BYTES,
-                        count: inputs.length
-                    });
-                    return { error: OVER_BUDGET_ERROR };
-                }
-                files[i] = { path: input.path, bytes };
-                continue;
+            const probe = id === undefined
+                ? await probeUpload(fetchAttachment, input, {
+                    index: uploads++,
+                    turnImages,
+                    signal,
+                    deadline
+                })
+                : await probeAttachment(fetchAttachment, id, { signal, deadline });
+            if ('error' in probe) {
+                return probe;
             }
-            const head = await bounded(fetchAttachment({ attachmentId: id, meta: true, signal }), deadline - Date.now(), STAGE_TIMEOUT_MESSAGE);
-            if (!head)
-                return { error: `attachment ${id} not found in this chat` };
-            total += byteLengthOf(head);
+            total += probe.size;
             if (total > MAX_INPUT_TOTAL_BYTES) {
                 hlog('python: input attachments over budget; skipping blob download', {
                     total,
@@ -86,32 +97,33 @@ export async function stageInputs(fetchAttachment, inputs, opts = {}) {
                 });
                 return { error: OVER_BUDGET_ERROR };
             }
-            if (hasBytes(head))
-                files[i] = { path: input.path, bytes: head.bytes };
-            else
-                pending.push(i);
+            if (probe.bytes !== null) {
+                files[i] = { path: input.path, bytes: probe.bytes };
+            }
+            else {
+                pending.push({ index: i, input });
+            }
         }
         catch (error) {
-            return { error: error instanceof Error ? error.message : String(error) };
+            return { error: errorMessage(error) };
         }
     }
-    for (const i of pending) {
-        const input = inputs[i];
+    for (const { index, input } of pending) {
         const id = input.attachmentId;
         try {
             const fetched = await bounded(fetchAttachment({ attachmentId: id, signal }), deadline - Date.now(), STAGE_TIMEOUT_MESSAGE);
             if (!fetched || !hasBytes(fetched)) {
                 return { error: `attachment ${id} not found in this chat` };
             }
-            files[i] = { path: input.path, bytes: fetched.bytes };
+            files[index] = { path: input.path, bytes: fetched.bytes };
         }
         catch (error) {
-            return { error: error instanceof Error ? error.message : String(error) };
+            return { error: errorMessage(error) };
         }
     }
-    return { files: files };
+    return { files: files.filter((file) => file !== null) };
 }
-export async function attachOutputs(attach, files, declared, runBudget) {
+export async function attachOutputs(attach, files, { declared, runBudget }) {
     const attachments = [];
     const missingOutputs = [];
     const rejectedOutputs = [];
@@ -145,8 +157,9 @@ export async function attachOutputs(attach, files, declared, runBudget) {
             continue;
         }
         total += bytes.byteLength;
-        if (runBudget)
+        if (runBudget) {
             runBudget.outputBytesUsed += bytes.byteLength;
+        }
         attachments.push({
             attachmentId: record.id,
             fileName: record.fileName,

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

@@ -1,7 +1,7 @@
-type SourceHalves = {
+interface SourceHalves {
     code: string;
     text: string;
-};
+}
 export declare function splitPythonSource(source: string): SourceHalves | null;
 export declare function pythonCreateEffect(args: Record<string, unknown>): 'read' | 'write';
 export {};