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

package/dist-lib/plugins/external-agents/cli.js

@@ -0,0 +1,199 @@
+import { isRecord } from '../../lib/guards.js';
+import { graceMs } from './targets.js';
+const CLAUDE_TOOLS = { read: 'Read,Grep,Glob', write: 'Read,Grep,Glob,Edit,Write,Bash' };
+const OUTPUT_CHARS = 4_000;
+const USER_LOGIN = ['--setting-sources', 'user', '--strict-mcp-config'];
+export const claudeCli = {
+    argv: (task, config) => [
+        ...(config.login === 'user' ? USER_LOGIN : ['--bare']),
+        '-p',
+        '--output-format',
+        'stream-json',
+        '--verbose',
+        '--no-session-persistence',
+        '--permission-mode',
+        'dontAsk',
+        '--permission-prompts',
+        'none',
+        ...(config.maxTurns === undefined ? [] : ['--max-turns', String(config.maxTurns)]),
+        ...(config.maxCostUsd === undefined ? [] : ['--max-budget-usd', String(config.maxCostUsd)]),
+        '--allowedTools',
+        CLAUDE_TOOLS[task.access]
+    ],
+    drive: cliDriver(claudeEvent)
+};
+export const codexCli = {
+    argv: (task) => [
+        'exec',
+        '--json',
+        '--ephemeral',
+        '--skip-git-repo-check',
+        '-C',
+        task.workdir,
+        '--sandbox',
+        task.access === 'read' ? 'read-only' : 'workspace-write',
+        '-'
+    ],
+    drive: cliDriver(codexEvent)
+};
+function cliDriver(parse) {
+    return async ({ config, child, task, signal }) => {
+        const run = { text: '', transcript: [], final: null };
+        if (signal.aborted) {
+            const exit = await child.stop(0, ['SIGKILL']);
+            return { status: 'aborted', text: '', transcript: [{ type: 'end', exit }] };
+        }
+        child.onLine((line) => {
+            const event = parsed(line);
+            const seen = run.transcript.length;
+            if (event) {
+                parse(run, event);
+            }
+            for (const entry of run.transcript.slice(seen)) {
+                task.onEvent?.(entry);
+            }
+        });
+        const onAbort = () => void child.stop(graceMs(config), ['SIGINT', 'SIGTERM', 'SIGKILL']);
+        signal.addEventListener('abort', onAbort, { once: true });
+        child.write(task.prompt);
+        child.end();
+        const exit = await child.closed;
+        signal.removeEventListener('abort', onAbort);
+        run.transcript.push({ type: 'end', exit });
+        if (signal.aborted) {
+            return {
+                status: 'aborted',
+                text: run.text,
+                usage: run.final?.usage,
+                transcript: run.transcript
+            };
+        }
+        return run.final
+            ? { ...run.final, transcript: run.transcript }
+            : { status: 'error', text: 'the agent ended without a result', transcript: run.transcript };
+    };
+}
+function parsed(line) {
+    try {
+        const event = JSON.parse(line);
+        return isRecord(event) ? event : null;
+    }
+    catch {
+        return null;
+    }
+}
+function claudeEvent(run, event) {
+    const blocks = Array.isArray(Object(event.message).content)
+        ? Object(event.message).content
+        : [];
+    if (event.type === 'assistant' || event.type === 'user') {
+        for (const block of blocks.map(Object)) {
+            claudeBlock(run, block);
+        }
+    }
+    else if (event.type === 'result') {
+        claudeResult(run, event);
+    }
+}
+function claudeBlock(run, block) {
+    if (block.type === 'text') {
+        run.text += String(block.text);
+        run.transcript.push({ type: 'message', text: block.text });
+    }
+    else if (block.type === 'thinking') {
+        run.transcript.push({ type: 'thought', text: block.thinking });
+    }
+    else if (block.type === 'tool_use') {
+        const { id, name: title, input } = block;
+        run.transcript.push({ type: 'tool', id, title, status: 'pending', input });
+    }
+    else if (block.type === 'tool_result') {
+        const status = block.is_error === true ? 'failed' : 'completed';
+        run.transcript.push({
+            type: 'tool',
+            id: block.tool_use_id,
+            status,
+            output: text(block.content)
+        });
+    }
+}
+function text(content) {
+    const parts = Array.isArray(content) ? content : [content];
+    const joined = parts
+        .map((part) => (typeof part === 'string' ? part : String(Object(part).text ?? '')))
+        .join('');
+    return joined.length > OUTPUT_CHARS ? `${joined.slice(0, OUTPUT_CHARS)}…` : joined;
+}
+function claudeResult(run, event) {
+    const denials = Array.isArray(event.permission_denials) ? event.permission_denials : [];
+    for (const denial of denials.map(Object)) {
+        run.transcript.push({ type: 'permission', title: denial.tool_name, answer: 'denied' });
+    }
+    const usage = Object(event.usage);
+    const status = () => {
+        if (event.subtype === 'error_max_turns' || event.subtype === 'error_max_budget_usd') {
+            return 'budget';
+        }
+        return event.subtype === 'success' && event.is_error !== true ? 'answered' : 'error';
+    };
+    run.final = {
+        status: status(),
+        text: typeof event.result === 'string' ? event.result : run.text,
+        usage: numbers({
+            inputTokens: usage.input_tokens,
+            outputTokens: usage.output_tokens,
+            costUsd: event.total_cost_usd,
+            turns: event.num_turns
+        })
+    };
+}
+function codexEvent(run, event) {
+    if (event.type === 'item.completed') {
+        codexItem(run, Object(event.item));
+    }
+    else if (event.type === 'turn.completed') {
+        const usage = Object(event.usage);
+        run.final = {
+            status: 'answered',
+            text: run.text,
+            usage: numbers({ inputTokens: usage.input_tokens, outputTokens: usage.output_tokens })
+        };
+    }
+    else if (event.type === 'turn.failed' || event.type === 'error') {
+        const message = String(Object(event.error).message ?? event.message ?? 'the turn failed');
+        run.transcript.push({ type: 'error', message });
+        run.final = { status: 'error', text: message, usage: undefined };
+    }
+}
+function codexItem(run, item) {
+    const changes = Array.isArray(item.changes) ? item.changes : [];
+    if (item.type === 'agent_message') {
+        run.text = String(item.text);
+        run.transcript.push({ type: 'message', text: item.text });
+    }
+    else if (item.type === 'reasoning') {
+        run.transcript.push({ type: 'thought', text: item.text });
+    }
+    else if (item.type === 'command_execution') {
+        const { id, command: title, status } = item;
+        run.transcript.push({ type: 'tool', id, title, kind: 'execute', status });
+    }
+    else if (item.type === 'file_change') {
+        const paths = changes.map((change) => Object(change).path);
+        run.transcript.push({ type: 'tool', id: item.id, kind: 'edit', status: item.status, paths });
+    }
+    else if (item.type === 'mcp_tool_call' || item.type === 'web_search') {
+        run.transcript.push({ type: 'tool', id: item.id, kind: item.type, status: item.status });
+    }
+}
+const USAGE_KEYS = ['inputTokens', 'outputTokens', 'costUsd', 'turns'];
+function numbers(usage) {
+    const out = {};
+    for (const key of USAGE_KEYS) {
+        const value = usage[key];
+        if (typeof value === 'number') {
+            out[key] = value;
+        }
+    }
+    return out;
+}

package/dist-lib/plugins/external-agents/index.d.ts

@@ -0,0 +1,25 @@
+import type { DelegateTarget } from '../../lib/agent/index.ts';
+import type { HarnessPlugin, PluginSetup } from '../../lib/plugins/index.ts';
+import { type AgentTargetConfig } from './targets.ts';
+declare module '../../lib/plugins/context.ts' {
+    interface Services {
+        delegateTargets: readonly DelegateTarget[];
+    }
+}
+export type { AgentLogin, AgentProtocol, AgentTargetConfig } from './targets.ts';
+export interface ExternalAgentsOptions {
+    dir: string;
+    targets: readonly AgentTargetConfig[];
+}
+type Preset = Pick<AgentTargetConfig, 'protocol' | 'command' | 'keyEnv' | 'description'>;
+export declare class ExternalAgents implements HarnessPlugin {
+    static readonly PRESETS: Readonly<Record<'claude-agent-acp' | 'codex-acp', Preset>>;
+    static targets({ dir, targets }: ExternalAgentsOptions): DelegateTarget[];
+    readonly name = "external-agents";
+    readonly api = 1;
+    readonly provides: string[];
+    private readonly _options;
+    constructor(options: ExternalAgentsOptions);
+    validate(): string | null;
+    setup(): PluginSetup;
+}

package/dist-lib/plugins/external-agents/index.js

@@ -0,0 +1,54 @@
+import { PluginRegistry } from '../../lib/plugins/index.js';
+import { claudeCli, codexCli } from './cli.js';
+import { acpDriver, agentTarget } from './targets.js';
+const LOGINS = ['isolated', 'user'];
+const PROTOCOLS = {
+    acp: { argv: () => [], drive: acpDriver },
+    claude: claudeCli,
+    codex: codexCli
+};
+export class ExternalAgents {
+    static PRESETS = {
+        'claude-agent-acp': {
+            protocol: 'acp',
+            command: 'claude-agent-acp',
+            keyEnv: 'ANTHROPIC_API_KEY',
+            description: 'Claude Code, a coding agent that reads and edits the project'
+        },
+        'codex-acp': {
+            protocol: 'acp',
+            command: 'codex-acp',
+            keyEnv: 'CODEX_API_KEY',
+            description: 'Codex, a coding agent that reads and edits the project'
+        }
+    };
+    static targets({ dir, targets }) {
+        return targets.map((config) => agentTarget(config, dir, PROTOCOLS[config.protocol]));
+    }
+    name = 'external-agents';
+    api = PluginRegistry.API_VERSION;
+    provides = ['delegateTargets'];
+    _options;
+    constructor(options) {
+        this._options = options;
+    }
+    validate() {
+        const config = this._options;
+        if (!config?.dir || !Array.isArray(config.targets)) {
+            return 'needs a dir and a list of targets';
+        }
+        const names = config.targets.map((target) => target.name);
+        if (new Set(names).size !== names.length || names.includes('local')) {
+            return 'target names must be unique and not "local"';
+        }
+        if (!config.targets.every((target) => target.protocol in PROTOCOLS && target.command)) {
+            return `each target needs a protocol (${Object.keys(PROTOCOLS).join(', ')}) and a command`;
+        }
+        return config.targets.every((target) => LOGINS.includes(target.login ?? 'isolated'))
+            ? null
+            : `a target's login must be ${LOGINS.join(' or ')}`;
+    }
+    setup() {
+        return { services: { delegateTargets: ExternalAgents.targets(this._options) } };
+    }
+}

package/dist-lib/plugins/external-agents/process.d.ts

@@ -0,0 +1,19 @@
+export interface Exit {
+    code: number | null;
+    signal: string | null;
+}
+export interface AgentProcess {
+    readonly exited: Promise<Exit>;
+    readonly closed: Promise<Exit>;
+    write(line: string): void;
+    end(): void;
+    onLine(handle: (line: string) => void): void;
+    stop(graceMs: number, signals: readonly (string | null)[]): Promise<Exit>;
+    stderr(): string;
+}
+export interface SpawnOptions {
+    cwd: string;
+    env: Record<string, string>;
+}
+export declare function spawnAgent(command: string, args: readonly string[], { cwd, env }: SpawnOptions): AgentProcess;
+export declare function agentEnv(home: string | null, keyEnv?: string, key?: string | null): Record<string, string>;

package/dist-lib/plugins/external-agents/process.js

@@ -0,0 +1,92 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import process from 'process';
+import { execEnv } from '../../lib/helpers/spawn-path.js';
+const STDERR_TAIL = 2_000;
+export function spawnAgent(command, args, { cwd, env }) {
+    const child = spawn(command, [...args], { cwd, env, stdio: ['pipe', 'pipe', 'pipe'] });
+    let stderr = '';
+    let partial = '';
+    const listeners = [];
+    const exited = new Promise((resolve) => {
+        child.on('exit', (code, signal) => resolve({ code, signal: signal ?? null }));
+        child.on('error', () => resolve({ code: null, signal: null }));
+    });
+    const closed = new Promise((resolve) => {
+        child.on('close', (code, signal) => resolve({ code, signal: signal ?? null }));
+        child.on('error', () => resolve({ code: null, signal: null }));
+    });
+    child.stdin?.on('error', () => { });
+    child.stderr?.on('data', (chunk) => {
+        stderr = (stderr + String(chunk)).slice(-STDERR_TAIL);
+    });
+    child.stdout?.on('data', (chunk) => {
+        const lines = (partial + String(chunk)).split('\n');
+        partial = lines.pop() ?? '';
+        for (const line of lines) {
+            for (const listener of listeners) {
+                listener(line);
+            }
+        }
+    });
+    let done = null;
+    let ended = false;
+    const end = () => {
+        if (!done && !ended) {
+            child.stdin?.end();
+        }
+        ended = true;
+    };
+    void exited.then((exit) => {
+        done = exit;
+    });
+    return {
+        exited,
+        closed,
+        write: (line) => {
+            if (!done) {
+                child.stdin?.write(`${line}\n`);
+            }
+        },
+        end,
+        onLine: (handle) => {
+            listeners.push(handle);
+        },
+        async stop(graceMs, signals) {
+            end();
+            for (const signal of signals) {
+                if (done) {
+                    return done;
+                }
+                if (signal && child.pid !== undefined) {
+                    send(child.pid, signal);
+                }
+                await Promise.race([exited, wait(graceMs)]);
+            }
+            return exited;
+        },
+        stderr: () => stderr
+    };
+}
+function send(pid, signal) {
+    try {
+        process.kill(pid, signal);
+    }
+    catch {
+    }
+}
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function agentEnv(home, keyEnv, key) {
+    const env = execEnv(process.env, process.platform);
+    if (home) {
+        env.HOME = home;
+        env.CODEX_HOME = path.join(home, 'codex');
+        env.CLAUDE_CONFIG_DIR = path.join(home, 'claude');
+    }
+    if (keyEnv && key) {
+        env[keyEnv] = key;
+    }
+    return env;
+}

package/dist-lib/plugins/external-agents/targets.d.ts

@@ -0,0 +1,32 @@
+import type { DelegateTarget, TargetResult, TargetTask } from '../../lib/agent/index.ts';
+import { type AgentProcess } from './process.ts';
+export type AgentProtocol = 'acp' | 'claude' | 'codex';
+export type AgentLogin = 'isolated' | 'user';
+export interface AgentTargetConfig {
+    name: string;
+    description: string;
+    protocol: AgentProtocol;
+    command: string;
+    args?: readonly string[];
+    keyEnv?: string;
+    key?: () => Promise<string | null>;
+    maxTurns?: number;
+    maxCostUsd?: number;
+    graceMs?: number;
+    login?: AgentLogin;
+}
+export interface Drive {
+    config: AgentTargetConfig;
+    child: AgentProcess;
+    task: TargetTask;
+    signal: AbortSignal;
+}
+export type Driver = (drive: Drive) => Promise<TargetResult>;
+export interface Protocol {
+    argv(task: TargetTask, config: AgentTargetConfig): string[];
+    drive: Driver;
+}
+export declare function graceMs(config: AgentTargetConfig): number;
+export declare function targetKey(config: AgentTargetConfig): Promise<string | null>;
+export declare function agentTarget(config: AgentTargetConfig, dir: string, { argv, drive }: Protocol): DelegateTarget;
+export declare const acpDriver: Driver;

package/dist-lib/plugins/external-agents/targets.js

@@ -0,0 +1,66 @@
+import fs from 'fs';
+import path from 'path';
+import { AcpClient, acpTurn } from './acp.js';
+import { agentEnv, spawnAgent } from './process.js';
+const GRACE_MS = 2_000;
+export function graceMs(config) {
+    return config.graceMs ?? GRACE_MS;
+}
+export function targetKey(config) {
+    return config.key ? config.key() : Promise.resolve(null);
+}
+export function agentTarget(config, dir, { argv, drive }) {
+    const home = config.login === 'user' ? null : path.join(dir, config.name);
+    return {
+        name: config.name,
+        description: config.description,
+        policyVersion: config.login ?? 'isolated',
+        async run(task, signal) {
+            const key = await targetKey(config);
+            if (home) {
+                await fs.promises.mkdir(home, { recursive: true });
+            }
+            if (signal.aborted) {
+                return { status: 'aborted', text: '', transcript: [] };
+            }
+            const child = spawnAgent(config.command, [...(config.args ?? []), ...argv(task, config)], {
+                cwd: task.workdir,
+                env: agentEnv(home, config.keyEnv, key)
+            });
+            const live = task.onEvent;
+            const onEvent = live && ((event) => live(redact(event, key)));
+            const ran = await drive({ config, child, task: { ...task, onEvent }, signal });
+            ended(ran, await child.stop(graceMs(config), [null, 'SIGTERM', 'SIGKILL']));
+            if (ran.status === 'error') {
+                ran.text = [ran.text, child.stderr().trim().slice(-500)].filter(Boolean).join(': ');
+            }
+            return redact(ran, key);
+        }
+    };
+}
+function ended(ran, exit) {
+    const last = ran.transcript.at(-1);
+    if (last?.type === 'end') {
+        last.exit = exit;
+    }
+    else {
+        ran.transcript.push({ type: 'end', exit });
+    }
+}
+function redact(value, key) {
+    if (!key) {
+        return value;
+    }
+    const text = JSON.stringify(value).split(JSON.stringify(key).slice(1, -1)).join('[redacted]');
+    return JSON.parse(text);
+}
+export const acpDriver = ({ config, child, task, signal }) => {
+    const client = new AcpClient((line) => child.write(line));
+    child.onLine((line) => client.receive(line));
+    void child.exited.then(() => client.close(new Error('the agent exited')));
+    return acpTurn(client, task, {
+        signal,
+        maxCostUsd: config.maxCostUsd,
+        graceMs: graceMs(config)
+    });
+};

package/dist-lib/{lib/tools → plugins/image}/edit-image.d.ts

@@ -1,5 +1,5 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import type { ImageClamps } from '../models/model-catalog.ts';
+import type { ToolDefinition } from '../../lib/contract/index.ts';
+import type { ImageClamps } from '../../lib/models/model-catalog.ts';
 import { type DiffusionRuntime } from './generate-image.ts';
 interface Rgba {
     width: number;
@@ -21,5 +21,6 @@ export interface EditImageDeps {
     loadMedia?: () => Promise<Media | null>;
     resample?: (rgba: Rgba, width: number, height: number) => Rgba | Promise<Rgba>;
 }
+export declare function loadMediaCodecs(): Promise<void>;
 export declare function createEditImageTool(runtime: DiffusionRuntime, { loadMedia, resample }?: EditImageDeps, clamps?: ImageClamps): ToolDefinition;
 export {};

package/dist-lib/{lib/tools → plugins/image}/edit-image.js

@@ -1,7 +1,7 @@
 import b4a from 'b4a';
 import fs from 'fs';
 import path from 'path';
-import { AbortedError } from '../helpers/race-abort.js';
+import { AbortedError } from '../../lib/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;
 const FLUX2_GUIDANCE = 3.5;
@@ -78,13 +78,18 @@ async function defaultResample(rgba, width, height) {
     const { resize } = await import('bare-image-resample');
     return resize(rgba, width, height);
 }
+export async function loadMediaCodecs() {
+    const media = await import('bare-media');
+    const codecs = media.codecs;
+    await Promise.all(Object.values(codecs).map((load) => load()));
+}
 export function createEditImageTool(runtime, { loadMedia = defaultLoadMedia, resample = defaultResample } = {}, clamps) {
     const cap = normalizeClamps(clamps);
     const stepsCap = clamps?.maxSteps ? cap.maxSteps : undefined;
     const snap = (n) => Math.min(cap.maxDim, Math.max(DIM_STEP, Math.round(n / DIM_STEP) * DIM_STEP));
     return {
         name: 'edit_image',
-        toolset: null,
+        toolset: 'image',
         skillGated: true,
         description: 'Edit or restyle an existing image from this chat using the local diffusion model ' +
             '(image-to-image). To edit what the user just attached, call with the prompt ONLY — the ' +

package/dist-lib/{lib/tools → plugins/image}/generate-image.d.ts

@@ -1,9 +1,9 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import type { ModelSrc } from '../models/context.ts';
-import { type ImageClamps } from '../models/model-catalog.ts';
-import { type LoadTracker, type TrackedLoad } from '../models/model-pool.ts';
-import { type ModelRegistrySdk } from '../models/model-source.ts';
+import type { ToolDefinition } from '../../lib/contract/index.ts';
+import type { ModelSrc } from '../../lib/models/context.ts';
+import { type ImageClamps, type ImageModelSet } from '../../lib/models/model-catalog.ts';
+import type { ModelHost, TrackedLoad } from '../../lib/contract/models.ts';
+import { type ModelRegistrySdk } from '../../lib/models/model-source.ts';
 export declare const MAX_DIM = 1024;
 export declare const DIM_STEP = 64;
 export declare const MAX_STEPS = 100;
@@ -57,19 +57,13 @@ export type DiffusionSdk = ModelRegistrySdk & {
         requestId: string;
     }): Promise<void>;
 };
-export interface ImageModelSet {
-    model: string;
-    llmModel?: string;
-    vaeModel?: string;
-    prediction?: 'flux2_flow';
-}
 export declare const IMAGE_LOAD_STALL_MS: number;
 export interface DiffusionRuntimeOptions extends ImageModelSet {
     loadSdk: () => Promise<DiffusionSdk>;
     onProgress?: (model: string, progress: Record<string, unknown>) => void;
     onLoaded?: (model: string) => void;
     onBeforeLoad?: (signal?: BareAbortSignal) => Promise<void>;
-    loads?: LoadTracker;
+    loads?: Pick<ModelHost, 'track'>;
     stallMs?: number;
 }
 export interface LoadedDiffusionModel {

package/dist-lib/{lib/tools → plugins/image}/generate-image.js

@@ -1,9 +1,8 @@
 import ScopeLock from 'scope-lock';
-import { AbortedError, raceAbort } from '../helpers/race-abort.js';
-import { DIFFUSION_CATALOG, imageModelFor } from '../models/model-catalog.js';
-import { createLoadStall } from '../helpers/load-stall.js';
-import { createLoadTracker } from '../models/model-pool.js';
-import { resolveModelSrc } from '../models/model-source.js';
+import { AbortedError, raceAbort } from '../../lib/helpers/race-abort.js';
+import { DIFFUSION_CATALOG, imageModelFor } from '../../lib/models/model-catalog.js';
+import { createLoadStall } from '../../lib/helpers/load-stall.js';
+import { resolveModelSrc } from '../../lib/models/model-source.js';
 export const MAX_DIM = 1024;
 export const DIM_STEP = 64;
 const DEFAULT_DIM = 512;
@@ -39,7 +38,7 @@ function diffusionProgressName(set) {
     return entry?.name ?? set.model;
 }
 export const IMAGE_LOAD_STALL_ERROR = 'image model download stalled';
-export function createDiffusionRuntime({ loadSdk, onProgress, onLoaded, onBeforeLoad, loads = createLoadTracker(), stallMs = IMAGE_LOAD_STALL_MS, ...base }) {
+export function createDiffusionRuntime({ loadSdk, onProgress, onLoaded, onBeforeLoad, loads = { track: (pending) => pending }, stallMs = IMAGE_LOAD_STALL_MS, ...base }) {
     let loading = null;
     let residentFingerprint = null;
     let busy = false;
@@ -279,7 +278,7 @@ export function createGenerateImageTool(runtime, clamps) {
     const stepsCap = clamps?.maxSteps ? cap.maxSteps : undefined;
     return {
         name: 'generate_image',
-        toolset: null,
+        toolset: 'image',
         skillGated: true,
         description: 'Generate an image from a text prompt using the local diffusion model. ' +
             `Width and height default to ${Math.min(DEFAULT_DIM, cap.maxDim)}, max ${cap.maxDim} ` +

package/dist-lib/plugins/image/index.d.ts

@@ -0,0 +1,25 @@
+import type { ImageClamps, ImageModelSet } from '../../lib/models/model-catalog.ts';
+import type { HarnessPlugin, PluginContext, PluginSetup } from '../../lib/plugins/index.ts';
+import { loadMediaCodecs } from './edit-image.ts';
+export { createEditImageTool } from './edit-image.ts';
+export { createDiffusionRuntime, createGenerateImageTool, generationPercentTick, IMAGE_LOAD_STALL_ERROR, settingsDimension, settingsSteps, type DiffusionRuntime, type DiffusionRuntimeOptions, type DiffusionSdk, type DiffusionTick } from './generate-image.ts';
+export interface ImageOptions {
+    model: string | ImageModelSet;
+    clamps?: ImageClamps;
+    read?: readonly string[];
+}
+export declare class Image implements HarnessPlugin {
+    readonly name = "image";
+    readonly api = 1;
+    readonly needs: string[];
+    readonly addons: {
+        'diffusion-cpp': () => Promise<typeof import("@qvac/diffusion-cpp/addonLogging")>;
+        'bare-image-resample': () => Promise<any>;
+        'bare-media': typeof loadMediaCodecs;
+    };
+    readonly read: readonly string[] | undefined;
+    private readonly _options;
+    constructor(options: ImageOptions);
+    validate(): string | null;
+    setup(ctx: PluginContext): PluginSetup;
+}