@qvac/harness 0.4.0 → 0.5.0

package/dist-lib/lib/tools/fs/glob.js

@@ -2,30 +2,25 @@ export function compileGlob(pattern) {
     let source = '';
     let i = 0;
     while (i < pattern.length) {
-        const c = pattern[i];
-        if (c === '*') {
-            if (pattern[i + 1] === '*') {
-                if (pattern[i + 2] === '/') {
-                    source += '(?:.*/)?';
-                    i += 3;
-                }
-                else {
-                    source += '.*';
-                    i += 2;
-                }
-            }
-            else {
-                source += '[^/]*';
-                i += 1;
-            }
+        const c = pattern.charAt(i);
+        if (c === '*' && pattern[i + 1] === '*' && pattern[i + 2] === '/') {
+            source += '(?:.*/)?';
+            i += 3;
+        }
+        else if (c === '*' && pattern[i + 1] === '*') {
+            source += '.*';
+            i += 2;
+        }
+        else if (c === '*') {
+            source += '[^/]*';
+            i += 1;
         }
         else if (c === '?') {
             source += '[^/]';
             i += 1;
         }
         else {
-            const ch = c;
-            source += /[.+^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
+            source += /[.+^${}()|[\]\\]/.test(c) ? `\\${c}` : c;
             i += 1;
         }
     }

package/dist-lib/lib/tools/fs/remote-protocol.d.ts

@@ -1,34 +1,34 @@
 import type { DriveEntry } from './drive.ts';
-export type DriveEntryRequest = {
+export interface DriveEntryRequest {
     op: 'entry';
     driveKey: string;
     key: string;
-};
-export type DriveGetRequest = {
+}
+export interface DriveGetRequest {
     op: 'get';
     driveKey: string;
     key: string;
-};
-export type DriveReadRequest = {
+}
+export interface DriveReadRequest {
     op: 'read';
     driveKey: string;
     key: string;
-};
-export type DriveListRequest = {
+}
+export interface DriveListRequest {
     op: 'list';
     driveKey: string;
     folder: string;
     skip: string[];
     limit: number;
     cursor: string | null;
-};
-export type DriveWriteRequest = {
+}
+export interface DriveWriteRequest {
     op: 'write';
     driveKey: string;
     key: string;
     path: string;
     executable?: boolean;
-};
+}
 export type DriveRequest = DriveEntryRequest | DriveGetRequest | DriveReadRequest | DriveListRequest | DriveWriteRequest;
 export interface DriveResponse {
     error?: string;

package/dist-lib/lib/tools/fs/remote.d.ts

@@ -12,6 +12,7 @@ export declare class DriveReadTruncatedError extends Error {
     constructor(key: string);
 }
 export declare function isDriveReadTruncated(err: unknown): err is DriveReadTruncatedError;
-export declare function createRemoteRoots(drives: readonly GrantedDrive[], driveOp: DriveOpFn, opts?: {
+export interface RemoteRootsOptions {
     readonly timeoutMs?: number;
-}): HyperRoot[];
+}
+export declare function createRemoteRoots(drives: readonly GrantedDrive[], driveOp: DriveOpFn, opts?: RemoteRootsOptions): HyperRoot[];

package/dist-lib/lib/tools/fs/remote.js

@@ -29,8 +29,9 @@ function withTimeout(promise, ms, op) {
 }
 async function call(driveOp, request, timeoutMs) {
     const response = await withTimeout(driveOp(request), timeoutMs, request.op);
-    if (response.error)
+    if (response.error) {
         throw new Error(response.error);
+    }
     return response;
 }
 async function readStaged(stagedPath) {
@@ -54,8 +55,9 @@ function remoteDrive(driveKey, driveOp, timeoutMs) {
         },
         async get(getKey) {
             const response = await call(driveOp, { op: 'get', driveKey, key: getKey }, timeoutMs);
-            if (!response.path)
+            if (!response.path) {
                 return null;
+            }
             return readStaged(response.path);
         },
         async *list(folder = '/', opts) {
@@ -64,25 +66,29 @@ function remoteDrive(driveKey, driveOp, timeoutMs) {
             while (true) {
                 const response = await call(driveOp, { op: 'list', driveKey, folder, skip, limit: DRIVE_LIST_PAGE, cursor }, timeoutMs);
                 const entries = response.entries ?? [];
-                for (const entry of entries)
+                for (const entry of entries) {
                     yield entry;
-                if (!response.cursor || entries.length === 0)
+                }
+                if (!response.cursor || entries.length === 0) {
                     return;
+                }
                 cursor = response.cursor;
             }
         },
         async *createReadStream(readKey) {
             const response = await call(driveOp, { op: 'read', driveKey, key: readKey }, timeoutMs);
-            if (!response.path)
+            if (!response.path) {
                 return;
+            }
             try {
                 yield* fs.createReadStream(response.path);
             }
             finally {
                 await fs.promises.unlink(response.path).catch(noop);
             }
-            if (response.truncated)
+            if (response.truncated) {
                 throw new DriveReadTruncatedError(readKey);
+            }
         },
         createWriteStream(writeKey, writeOpts) {
             const stagedPath = stagedWritePath();
@@ -108,7 +114,7 @@ function remoteDrive(driveKey, driveOp, timeoutMs) {
                             driveKey,
                             key: writeKey,
                             path: stagedPath,
-                            ...(writeOpts?.executable ? { executable: true } : {})
+                            executable: writeOpts?.executable || undefined
                         }, timeoutMs).then(() => cb(null), (err) => {
                             fs.promises.unlink(stagedPath).catch(noop);
                             cb(err);

package/dist-lib/lib/tools/fs/scope.d.ts

@@ -19,6 +19,9 @@ export interface FsToolOptions {
     readonly deniedRoots?: readonly string[];
 }
 export declare const NO_DIRS_GRANTED = "no directories are granted";
+export interface FsToolError {
+    error: string;
+}
 export declare const NO_STORAGE_ROOT = "cannot fence the app storage root: the SDK home is unknown";
 export declare function deniedRootsFor(sdkHome: string | undefined): readonly string[];
 export declare const PROTECTED_PATH_ERROR = "path is inside a protected app directory";
@@ -32,6 +35,8 @@ export interface ResolvedKey {
     key: string;
     exists: boolean;
 }
-export declare function resolveKey(p: string, roots: readonly DriveRoot[], realpath: Realpath, deny?: readonly string[]): Promise<ResolvedKey | {
-    error: string;
-}>;
+export interface ResolveKeyOptions {
+    readonly realpath: Realpath;
+    readonly deny?: readonly string[];
+}
+export declare function resolveKey(p: string, roots: readonly DriveRoot[], { realpath, deny }: ResolveKeyOptions): Promise<ResolvedKey | FsToolError>;

package/dist-lib/lib/tools/fs/scope.js

@@ -33,13 +33,13 @@ export async function canonicalDenyRoots(deniedRoots, realpath) {
     }));
 }
 export function isDeniedPath(hostPath, canonicalDenyRoots) {
-    return canonicalDenyRoots.some((root) => contained(hostPath, root, true));
+    return canonicalDenyRoots.some((root) => contained(hostPath, root, { ignoreCase: true }));
 }
 const FOLD_CASE = process.platform === 'darwin' || process.platform === 'win32';
 function within(candidate, root) {
-    return contained(candidate, root, FOLD_CASE);
+    return contained(candidate, root, { ignoreCase: FOLD_CASE });
 }
-function contained(candidate, root, ignoreCase) {
+function contained(candidate, root, { ignoreCase }) {
     const a = ignoreCase ? candidate.toLowerCase() : candidate;
     const b = ignoreCase ? root.toLowerCase() : root;
     return a === b || a.startsWith(b + path.sep);
@@ -66,17 +66,20 @@ export function normalizeDriveKey(prefix, input) {
         return null;
     if (WINDOWS_DRIVE_LETTER.test(input))
         return null;
-    if (CONTROL_OR_NUL.test(input))
+    if (CONTROL_OR_NUL.test(input)) {
         return null;
-    if (input.includes('://'))
+    }
+    if (input.includes('://')) {
         return null;
+    }
     const segments = [];
     for (const segment of input.split('/')) {
         if (segment === '' || segment === '.')
             continue;
         if (segment === '..') {
-            if (segments.length === 0)
+            if (segments.length === 0) {
                 return null;
+            }
             segments.pop();
             continue;
         }
@@ -88,19 +91,22 @@ export function normalizeDriveKey(prefix, input) {
 function matchHyperRoot(rest, roots) {
     return roots.find((r) => rest === r.key || rest.startsWith(r.key + '/'));
 }
-export async function resolveKey(p, roots, realpath, deny = []) {
-    if (roots.length === 0)
+export async function resolveKey(p, roots, { realpath, deny = [] }) {
+    if (roots.length === 0) {
         return { error: NO_DIRS_GRANTED };
+    }
     if (p.startsWith(HYPER_PREFIX)) {
         const rest = p.slice(HYPER_PREFIX.length);
         const hyperRoots = roots.filter((r) => r.kind === 'hyper');
         const root = matchHyperRoot(rest, hyperRoots);
-        if (!root)
+        if (!root) {
             return outside(roots);
+        }
         const tail = rest.slice(root.key.length);
         const key = normalizeDriveKey(root.prefix, tail || '/');
-        if (key === null)
+        if (key === null) {
             return outside(roots);
+        }
         return { root, key, exists: true };
     }
     const localRoots = roots.filter((r) => r.kind === 'local');
@@ -111,8 +117,9 @@ export async function resolveKey(p, roots, realpath, deny = []) {
             const canonical = await realpath(ancestor);
             const target = tail.length ? path.join(canonical, ...tail) : canonical;
             const root = localRoots.find((r) => within(target, r.root));
-            if (!root)
+            if (!root) {
                 return outside(roots);
+            }
             if (isDeniedPath(target, deny)) {
                 return protectedPath();
             }
@@ -120,8 +127,9 @@ export async function resolveKey(p, roots, realpath, deny = []) {
         }
         catch {
             const parent = path.dirname(ancestor);
-            if (parent === ancestor)
+            if (parent === ancestor) {
                 break;
+            }
             tail.unshift(path.basename(ancestor));
             ancestor = parent;
         }

package/dist-lib/lib/tools/fs/walk.js

@@ -1,3 +1,4 @@
+import { errorMessage } from '../../guards.js';
 import { hlog } from '../../log.js';
 import { displayPath } from './scope.js';
 export const WALK_SKIP_DIRS = new Set(['.git', 'node_modules']);
@@ -10,10 +11,12 @@ export async function walkFiles(root, folder = '/') {
     const deadline = Date.now() + MAX_WALK_MS;
     try {
         for await (const entry of root.drive.list(folder, { skip: WALK_SKIP_DIRS })) {
-            if (++visited > MAX_WALK_ENTRIES)
+            if (++visited > MAX_WALK_ENTRIES) {
                 return { files, truncated: true, skippedLinks };
-            if (Date.now() > deadline)
+            }
+            if (Date.now() > deadline) {
                 return { files, truncated: true, skippedLinks };
+            }
             if (entry.value.linkname !== null) {
                 skippedLinks++;
                 continue;
@@ -30,7 +33,7 @@ export async function walkFiles(root, folder = '/') {
             root: displayPath(root, '/'),
             folder,
             visited,
-            err: err.message
+            err: errorMessage(err)
         });
         return { files, truncated: true, skippedLinks };
     }

package/dist-lib/lib/tools/fs/write.d.ts

@@ -1,4 +1,5 @@
 import type { Drive } from './drive.ts';
-export declare function writeText(drive: Drive, key: string, text: string, opts?: {
+export interface WriteTextOptions {
     executable?: boolean;
-}): Promise<void>;
+}
+export declare function writeText(drive: Drive, key: string, text: string, opts?: WriteTextOptions): Promise<void>;

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

@@ -89,22 +89,24 @@ export declare function generationPercentTick(onPercent: (percentage: number) =>
 export declare const IMAGE_LOAD_STALL_ERROR = "image model download stalled";
 export declare function createDiffusionRuntime({ loadSdk, onProgress, onLoaded, onBeforeLoad, loads, stallMs, ...base }: DiffusionRuntimeOptions): DiffusionRuntime;
 export declare const BUSY_ERROR = "an image generation is already running; try again when it finishes";
-export declare function runDiffusion(sdk: DiffusionSdk, modelId: string, params: DiffusionParams, signal?: BareAbortSignal, onTick?: (tick: DiffusionTick) => void): Promise<Uint8Array | {
+export interface ImageToolError {
     error: string;
-}>;
+}
+export interface RunDiffusionOptions {
+    readonly modelId: string;
+    readonly params: DiffusionParams;
+    readonly signal?: BareAbortSignal;
+    readonly onTick?: (tick: DiffusionTick) => void;
+}
+export declare function runDiffusion(sdk: DiffusionSdk, { modelId, params, signal, onTick }: RunDiffusionOptions): Promise<Uint8Array | ImageToolError>;
 export interface CommonImageArgs {
     prompt: string;
     steps?: number;
     seed?: number;
     negativePrompt?: string;
 }
-export declare function parseCommonArgs(args: Record<string, unknown>, maxSteps?: number): CommonImageArgs | {
-    error: string;
-};
-export declare function normalizeClamps(clamps?: ImageClamps): {
-    maxDim: number;
-    maxSteps: number;
-};
+export declare function parseCommonArgs(args: Record<string, unknown>, maxSteps?: number): CommonImageArgs | ImageToolError;
+export declare function normalizeClamps(clamps?: ImageClamps): Required<ImageClamps>;
 export declare function settingsDimension(value: number | undefined, maxDim?: number): number | undefined;
 export declare function settingsSteps(value: number | undefined, maxSteps?: number): number | undefined;
 export declare function effectiveSteps(parsedSteps: number | undefined, settingsValue: number | undefined, stepsCap: number | undefined): number | undefined;

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

@@ -22,11 +22,13 @@ export function generationPercentTick(onPercent, encodePhases = 0) {
         }
         prevStep = step;
         prevTotal = totalSteps;
-        if (phase !== encodePhases)
+        if (phase !== encodePhases) {
             return;
+        }
         const percentage = totalSteps > 0 ? Math.min(100, Math.max(0, Math.round((step / totalSteps) * 100))) : 0;
-        if (percentage <= last)
+        if (percentage <= last) {
             return;
+        }
         last = percentage;
         onPercent(percentage);
     };
@@ -76,19 +78,23 @@ export function createDiffusionRuntime({ loadSdk, onProgress, onLoaded, onBefore
             const fingerprint = fingerprintOf(set);
             await lock.lock();
             try {
-                if (loading && residentFingerprint !== fingerprint)
+                if (loading && residentFingerprint !== fingerprint) {
                     await doUnload();
-                if (!loading && onBeforeLoad)
+                }
+                if (!loading && onBeforeLoad) {
                     await onBeforeLoad(signal);
+                }
                 residentFingerprint = fingerprint;
                 loading ??= (async () => {
                     onProgress?.(diffusionProgressName(set), {});
                     const modelSrc = await resolveModelSrc(sdk, set.model, 'diffusion');
                     const config = {};
-                    if (set.prediction)
+                    if (set.prediction) {
                         config.prediction = set.prediction;
-                    if (set.llmModel)
+                    }
+                    if (set.llmModel) {
                         config.llmModelSrc = await resolveModelSrc(sdk, set.llmModel, 'llm');
+                    }
                     if (set.vaeModel) {
                         config.vaeModelSrc = await resolveModelSrc(sdk, set.vaeModel, 'diffusion');
                     }
@@ -112,7 +118,7 @@ export function createDiffusionRuntime({ loadSdk, onProgress, onLoaded, onBefore
                         if (err instanceof Error &&
                             err.message === IMAGE_LOAD_STALL_ERROR &&
                             pending.requestId) {
-                            void sdk.cancel?.({ requestId: pending.requestId }).catch(() => { });
+                            void sdk.cancel?.({ requestId: pending.requestId }).catch(noop);
                         }
                         throw err;
                     }
@@ -139,33 +145,39 @@ export function createDiffusionRuntime({ loadSdk, onProgress, onLoaded, onBefore
     };
 }
 export const BUSY_ERROR = 'an image generation is already running; try again when it finishes';
-export async function runDiffusion(sdk, modelId, params, signal, onTick) {
+export async function runDiffusion(sdk, { modelId, params, signal, onTick }) {
     const onAbort = () => {
-        void sdk.cancel?.({ operation: 'inference', modelId }).catch(() => { });
+        void sdk.cancel?.({ operation: 'inference', modelId }).catch(noop);
     };
-    if (signal?.aborted)
+    if (signal?.aborted) {
         return { error: 'image generation canceled' };
+    }
     signal?.addEventListener('abort', onAbort, { once: true });
     let settled = false;
     try {
         const run = sdk.diffusion({ modelId, vae_tiling: true, ...params });
         const drained = (async () => {
-            for await (const tick of run.progressStream)
-                if (!settled)
+            for await (const tick of run.progressStream) {
+                if (!settled) {
                     onTick?.(tick);
-        })().catch(() => { });
+                }
+            }
+        })().catch(noop);
         const outputs = await run.outputs;
         await drained;
         const image = outputs[0];
-        if (signal?.aborted)
+        if (signal?.aborted) {
             return { error: 'image generation canceled' };
-        if (!image?.length)
+        }
+        if (!image?.length) {
             return { error: 'the diffusion model produced no image' };
+        }
         return image;
     }
     catch (err) {
-        if (signal?.aborted)
+        if (signal?.aborted) {
             return { error: 'image generation canceled' };
+        }
         throw err;
     }
     finally {
@@ -175,8 +187,9 @@ export async function runDiffusion(sdk, modelId, params, signal, onTick) {
 }
 export function parseCommonArgs(args, maxSteps = MAX_STEPS) {
     const prompt = typeof args.prompt === 'string' ? args.prompt.trim() : '';
-    if (!prompt)
+    if (!prompt) {
         return { error: 'prompt must be a non-empty string' };
+    }
     if (prompt.length > MAX_PROMPT_CHARS) {
         return { error: `prompt exceeds ${MAX_PROMPT_CHARS} characters` };
     }
@@ -194,8 +207,9 @@ export function parseCommonArgs(args, maxSteps = MAX_STEPS) {
         if (!Number.isInteger(seed) || seed < -1 || seed > MAX_SEED) {
             return { error: `seed must be an integer between -1 (random) and ${MAX_SEED}` };
         }
-        if (seed === -1)
+        if (seed === -1) {
             seed = undefined;
+        }
     }
     const negativePrompt = typeof args.negative_prompt === 'string' ? args.negative_prompt : undefined;
     if (negativePrompt && negativePrompt.length > MAX_PROMPT_CHARS) {
@@ -212,7 +226,7 @@ export function normalizeClamps(clamps) {
         : MAX_STEPS;
     return { maxDim, maxSteps };
 }
-function dimension(value, name, fallback, maxDim = MAX_DIM) {
+function dimension(value, { name, fallback, maxDim = MAX_DIM }) {
     if (value === undefined || value === null)
         return fallback;
     const n = Number(value);
@@ -238,15 +252,26 @@ export function effectiveSteps(parsedSteps, settingsValue, stepsCap) {
 }
 function parseArgs(args, defaults, cap) {
     const common = parseCommonArgs(args, cap.maxSteps);
-    if ('error' in common)
+    if ('error' in common) {
         return common;
+    }
     const fallback = Math.min(DEFAULT_DIM, cap.maxDim);
-    const width = dimension(args.width, 'width', defaults.width ?? fallback, cap.maxDim);
-    if (typeof width === 'object')
+    const width = dimension(args.width, {
+        name: 'width',
+        fallback: defaults.width ?? fallback,
+        maxDim: cap.maxDim
+    });
+    if (typeof width === 'object') {
         return width;
-    const height = dimension(args.height, 'height', defaults.height ?? fallback, cap.maxDim);
-    if (typeof height === 'object')
+    }
+    const height = dimension(args.height, {
+        name: 'height',
+        fallback: defaults.height ?? fallback,
+        maxDim: cap.maxDim
+    });
+    if (typeof height === 'object') {
         return height;
+    }
     return { ...common, width, height };
 }
 export function createGenerateImageTool(runtime, clamps) {
@@ -295,27 +320,36 @@ export function createGenerateImageTool(runtime, clamps) {
                 width: settingsDimension(ctx?.image?.width, cap.maxDim),
                 height: settingsDimension(ctx?.image?.height, cap.maxDim)
             }, cap);
-            if ('error' in parsed)
+            if ('error' in parsed) {
                 return parsed;
-            if (!ctx?.attach)
+            }
+            if (!ctx?.attach) {
                 return { error: 'this device cannot persist generated images' };
-            if (!runtime.acquire())
+            }
+            if (!runtime.acquire()) {
                 return { error: BUSY_ERROR, code: 'busy' };
+            }
             const report = ctx.progress;
             const onTick = report && generationPercentTick((percentage) => report({ percentage }));
             try {
                 const sdk = await runtime.loadSdk();
                 const { modelId } = await runtime.ensureLoaded(sdk, ctx.signal, ctx.image?.modelChoice);
-                const image = await runDiffusion(sdk, modelId, {
-                    prompt: parsed.prompt,
-                    width: parsed.width,
-                    height: parsed.height,
-                    steps: effectiveSteps(parsed.steps, ctx.image?.steps, stepsCap),
-                    seed: parsed.seed,
-                    negative_prompt: parsed.negativePrompt
-                }, ctx.signal, onTick);
-                if (!(image instanceof Uint8Array))
+                const image = await runDiffusion(sdk, {
+                    modelId,
+                    params: {
+                        prompt: parsed.prompt,
+                        width: parsed.width,
+                        height: parsed.height,
+                        steps: effectiveSteps(parsed.steps, ctx.image?.steps, stepsCap),
+                        seed: parsed.seed,
+                        negative_prompt: parsed.negativePrompt
+                    },
+                    signal: ctx.signal,
+                    onTick
+                });
+                if (!(image instanceof Uint8Array)) {
                     return image;
+                }
                 const record = await ctx.attach({
                     fileName: `generated-${Date.now()}.png`,
                     mimeType: 'image/png',
@@ -331,8 +365,9 @@ export function createGenerateImageTool(runtime, clamps) {
                 };
             }
             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 };
                 }
@@ -345,3 +380,4 @@ export function createGenerateImageTool(runtime, clamps) {
         }
     };
 }
+function noop() { }

package/dist-lib/lib/tools/generate-music.d.ts

@@ -81,11 +81,16 @@ export interface MusicRuntimeOptions extends MusicModelStages {
 export interface LoadedMusicModel {
     modelId: string;
 }
+export interface EnsureMusicLoadedOptions {
+    readonly signal?: BareAbortSignal;
+    readonly modelChoice?: string;
+    readonly inferenceSteps?: number;
+}
 export interface MusicRuntime {
     loadSdk: () => Promise<MusicGenSdk>;
     gpuRequested: boolean;
     defaultSteps?: number;
-    ensureLoaded: (sdk: MusicGenSdk, signal?: BareAbortSignal, modelChoice?: string, inferenceSteps?: number) => Promise<LoadedMusicModel>;
+    ensureLoaded: (sdk: MusicGenSdk, options?: EnsureMusicLoadedOptions) => Promise<LoadedMusicModel>;
     unload(): Promise<void>;
     unloadIdle(): Promise<void>;
     acquire(): boolean;
@@ -94,18 +99,27 @@ export interface MusicRuntime {
 export declare function musicPercentTick(onPercent: (percentage: number) => void): (tick: MusicTick) => void;
 export declare function createMusicRuntime({ loadSdk, onProgress, onBeforeLoad, loads, inferenceSteps: baseSteps, useGpu, ...base }: MusicRuntimeOptions): MusicRuntime;
 export declare const BUSY_ERROR = "a music generation is already running; try again when it finishes";
-export declare function runAudioGen(sdk: MusicGenSdk, modelId: string, params: AudioGenParams, signal?: BareAbortSignal, onTick?: (tick: MusicTick) => void): Promise<(GeneratedAudio & {
-    stats?: MusicStats;
-}) | {
+export interface MusicToolError {
     error: string;
-}>;
+}
+export interface GeneratedTrack extends GeneratedAudio {
+    stats?: MusicStats;
+}
+export interface RunAudioGenOptions {
+    readonly modelId: string;
+    readonly params: AudioGenParams;
+    readonly signal?: BareAbortSignal;
+    readonly onTick?: (tick: MusicTick) => void;
+}
+export declare function runAudioGen(sdk: MusicGenSdk, { modelId, params, signal, onTick }: RunAudioGenOptions): Promise<GeneratedTrack | MusicToolError>;
 export declare function audioDurationSeconds(audio: GeneratedAudio): number;
 export declare function presentStats(stats: MusicStats | undefined): MusicStats | undefined;
 export declare const CPU_FALLBACK_NOTICE = "The GPU was unavailable, so this track was generated on the CPU and took much longer than usual.";
-export declare function gpuFallback({ gpuRequested, stats }: {
+export interface GpuFallbackOptions {
     gpuRequested: boolean;
     stats: MusicStats | undefined;
-}): boolean;
+}
+export declare function gpuFallback({ gpuRequested, stats }: GpuFallbackOptions): boolean;
 export declare function backendDevice(stats: MusicStats | undefined): 'gpu' | 'cpu' | 'unknown';
 export declare function backendName(backendId: number | undefined): string;
 export declare function pcmToWav(audio: GeneratedAudio): Uint8Array;
@@ -115,10 +129,7 @@ export interface MusicClamps {
 }
 export declare function settingsDuration(value: number | undefined, maxDuration: number): number | undefined;
 export declare function settingsSteps(value: number | undefined, maxSteps?: number): number | undefined;
-export declare function normalizeClamps(clamps?: MusicClamps): {
-    maxDuration: number;
-    maxSteps: number;
-};
+export declare function normalizeClamps(clamps?: MusicClamps): Required<MusicClamps>;
 export declare function resolveMusicSettings(ctx: ToolExecuteContext | undefined): MusicSettings;
 export declare function createGenerateMusicTool(runtime: MusicRuntime, clamps?: MusicClamps): ToolDefinition;
 export {};