@qvac/harness 0.1.0 → 0.1.2

package/dist-lib/lib/hooks/pipeline.d.ts

@@ -0,0 +1,20 @@
+import type { ToolExecutionOutcome } from '../tool-call-display.ts';
+import type { HarnessHook, HookRejection, PostToolCallPayload, PreToolCallPayload, RunEndPayload, RunStartPayload } from './types.ts';
+export type PreToolFold = {
+    ok: true;
+    args: Record<string, unknown>;
+} | {
+    ok: false;
+    rejection: HookRejection;
+};
+export declare class HookPipeline {
+    private readonly _behaviorHooks;
+    constructor(hooks?: readonly HarnessHook[]);
+    onRunStart(payload: Omit<RunStartPayload, 'phase'>): Promise<void>;
+    onRunEnd(payload: Omit<RunEndPayload, 'phase'>): Promise<void>;
+    runPreToolFold(payload: Omit<PreToolCallPayload, 'phase'>): Promise<PreToolFold>;
+    runPostToolFold(payload: Omit<PostToolCallPayload, 'phase'>): Promise<{
+        result: unknown;
+        outcome?: ToolExecutionOutcome;
+    }>;
+}

package/dist-lib/lib/hooks/pipeline.js

@@ -0,0 +1,49 @@
+import { hlog } from "../log.js";
+import { normalizeToolExecutionOutcome } from "../helpers/run-outcome.js";
+import { harnessHooks } from "./registry.js";
+import { runHooks } from "./run.js";
+export class HookPipeline {
+    _behaviorHooks;
+    constructor(hooks = harnessHooks) {
+        this._behaviorHooks = hooks;
+    }
+    async onRunStart(payload) {
+        const folded = await runHooks(this._behaviorHooks, { phase: 'runStart', ...payload });
+        if ('guidance' in folded)
+            hlog('run hook failed', { stage: 'runStart', error: folded.error });
+    }
+    async onRunEnd(payload) {
+        const folded = await runHooks(this._behaviorHooks, { phase: 'runEnd', ...payload });
+        if ('guidance' in folded)
+            hlog('run hook failed', { stage: 'runEnd', error: folded.error });
+    }
+    async runPreToolFold(payload) {
+        const folded = await runHooks(this._behaviorHooks, { phase: 'preToolCall', ...payload });
+        if ('guidance' in folded) {
+            hlog('tool rejected: pre-hook refused the call', { tool: payload.toolName });
+            return { ok: false, rejection: folded };
+        }
+        return { ok: true, args: folded.args };
+    }
+    async runPostToolFold(payload) {
+        let result = payload.result;
+        let outcome = payload.outcome;
+        if (payload.executed) {
+            const folded = await runHooks(this._behaviorHooks, {
+                phase: 'postToolCall',
+                ...payload,
+                result
+            });
+            if ('guidance' in folded) {
+                result = folded;
+                outcome = { kind: 'guidance', message: folded.error };
+            }
+            else {
+                result = folded.result;
+            }
+        }
+        if (outcome !== undefined)
+            outcome = normalizeToolExecutionOutcome(result, outcome);
+        return { result, outcome };
+    }
+}

package/dist-lib/lib/hooks/registry.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessHook } from './types.ts';
+export declare const harnessHooks: HarnessHook[];

package/dist-lib/lib/hooks/registry.js

@@ -0,0 +1,6 @@
+import { ArgRepairHook, EgressGuardHook, SkillCatalogGuardHook } from "./built-in/index.js";
+export const harnessHooks = [
+    new ArgRepairHook(),
+    new EgressGuardHook(),
+    new SkillCatalogGuardHook()
+];

package/dist-lib/lib/hooks/run.d.ts

@@ -0,0 +1,5 @@
+import type { HarnessHook, HookRejection, PostToolCallPayload, PreToolCallPayload, RunEndPayload, RunStartPayload } from './types.ts';
+export declare function runHooks(hooks: readonly HarnessHook[], ctx: PreToolCallPayload): Promise<PreToolCallPayload | HookRejection>;
+export declare function runHooks(hooks: readonly HarnessHook[], ctx: PostToolCallPayload): Promise<PostToolCallPayload | HookRejection>;
+export declare function runHooks(hooks: readonly HarnessHook[], ctx: RunStartPayload): Promise<RunStartPayload | HookRejection>;
+export declare function runHooks(hooks: readonly HarnessHook[], ctx: RunEndPayload): Promise<RunEndPayload | HookRejection>;

package/dist-lib/lib/hooks/run.js

@@ -0,0 +1,83 @@
+import { hlog } from "../log.js";
+function cloneJson(value) {
+    try {
+        const text = JSON.stringify(value);
+        return text === undefined ? value : JSON.parse(text);
+    }
+    catch {
+        return value;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function cloneArgs(args) {
+    const cloned = cloneJson(args);
+    return isRecord(cloned) ? cloned : args;
+}
+function isMessage(value) {
+    return isRecord(value) && typeof value.role === 'string' && typeof value.content === 'string';
+}
+function freshContext(ctx) {
+    if (ctx.phase === 'preToolCall')
+        return { ...ctx, args: cloneArgs(ctx.args) };
+    if (ctx.phase === 'postToolCall') {
+        return { ...ctx, args: cloneArgs(ctx.args), result: cloneJson(ctx.result) };
+    }
+    if (ctx.phase === 'runStart') {
+        const cloned = cloneJson(ctx.messages);
+        return { ...ctx, messages: Array.isArray(cloned) ? cloned.filter(isMessage) : ctx.messages };
+    }
+    return { ...ctx };
+}
+function isRejection(value) {
+    return 'error' in value;
+}
+function rejection(value) {
+    return { error: String(value.error), guidance: true };
+}
+function merge(current, returned) {
+    if (current.phase === 'preToolCall' && 'args' in returned) {
+        return {
+            ...current,
+            args: returned.args
+        };
+    }
+    if (current.phase === 'postToolCall' && 'result' in returned) {
+        return {
+            ...current,
+            result: returned.result
+        };
+    }
+    return current;
+}
+function rejectionOf(current, err) {
+    const message = err instanceof Error ? err.message : String(err);
+    hlog('hook failed', { stage: current.phase, error: message });
+    if (current.phase === 'postToolCall') {
+        return {
+            error: `tool executed; output withheld: post-hook failed: ${message}. Do not retry this call.`,
+            guidance: true
+        };
+    }
+    return { error: `hook failed in ${current.phase}: ${message}`, guidance: true };
+}
+export async function runHooks(hooks, ctx) {
+    let current = ctx;
+    for (const hook of hooks) {
+        if (hook.phase !== current.phase)
+            continue;
+        try {
+            const returned = await hook.run(freshContext(current));
+            if (!returned || typeof returned !== 'object')
+                continue;
+            if (isRejection(returned))
+                return rejection(returned);
+            current = merge(current, returned);
+        }
+        catch (err) {
+            return rejectionOf(current, err);
+        }
+    }
+    return current;
+}

package/dist-lib/lib/hooks/types.d.ts

@@ -0,0 +1,57 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { ToolExecutionOutcome } from '../tool-call-display.ts';
+import type { Message, ResourceDescriptor, ToolDefinition, ToolEffect } from '../capabilities/completion.ts';
+export type HookPhase = 'runStart' | 'preToolCall' | 'postToolCall' | 'runEnd';
+export interface RunStartPayload {
+    readonly phase: 'runStart';
+    readonly agentId: string | null;
+    readonly messages: ReadonlyArray<Message>;
+}
+export interface PreToolCallPayload {
+    readonly phase: 'preToolCall';
+    readonly toolName: string;
+    readonly agentId: string | null;
+    readonly signal?: BareAbortSignal | undefined;
+    readonly skillNames?: readonly string[];
+    readonly parameters?: ToolDefinition['parameters'];
+    args: Record<string, unknown>;
+}
+export interface PostToolCallPayload {
+    readonly phase: 'postToolCall';
+    readonly toolName: string;
+    readonly executed: boolean;
+    readonly effect: ToolEffect;
+    readonly resource: ResourceDescriptor | null;
+    readonly agentId: string | null;
+    readonly args: Record<string, unknown>;
+    readonly toolset?: string | null;
+    readonly outcome?: ToolExecutionOutcome;
+    result: unknown;
+}
+export interface RunEndPayload {
+    readonly phase: 'runEnd';
+    readonly agentId: string | null;
+    readonly stats: {
+        readonly totalTokens: number;
+        readonly durationMs: number;
+        readonly timeToFirstToken?: number | undefined;
+    };
+    readonly outcome: 'done' | 'aborted' | 'error' | 'abandoned';
+    readonly error?: unknown;
+}
+export type HookContext = RunStartPayload | PreToolCallPayload | PostToolCallPayload | RunEndPayload;
+export interface HookRejection {
+    error: string;
+    guidance: true;
+}
+export interface PreToolCallResult {
+    readonly args: Record<string, unknown>;
+}
+export interface PostToolCallResult {
+    readonly result: unknown;
+}
+export type HookResult = PreToolCallResult | PostToolCallResult | HookRejection | void;
+export interface HarnessHook {
+    readonly phase: HookPhase;
+    run(ctx: HookContext): Promise<HookResult> | HookResult;
+}

package/dist-lib/lib/hooks/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+export declare function setHarnessLog(on: boolean): void;
+export declare function harnessLogEnabled(): boolean;
+export declare function setHarnessLogSink(next: ((line: string) => void) | null): void;
+export declare function hlog(message: string, data?: Record<string, unknown>): void;
+export declare function hdiag(message: string, data?: Record<string, unknown>): void;

package/dist-lib/lib/log.js

@@ -0,0 +1,37 @@
+import process from 'process';
+let enabled = process.env.QVAC_HARNESS_LOG === '1';
+export function setHarnessLog(on) {
+    enabled = on;
+}
+export function harnessLogEnabled() {
+    return enabled;
+}
+let sink = null;
+export function setHarnessLogSink(next) {
+    sink = next;
+}
+export function hlog(message, data) {
+    if (!enabled)
+        return;
+    const tail = data === undefined ? '' : ` ${safeJson(data)}`;
+    const line = `${message}${tail}`;
+    if (sink) {
+        sink(line);
+        return;
+    }
+    process.stdout.write(`${line}\n`);
+}
+export function hdiag(message, data) {
+    if (!sink)
+        return;
+    const tail = data === undefined ? '' : ` ${safeJson(data)}`;
+    sink(`${message}${tail}`);
+}
+function safeJson(data) {
+    try {
+        return JSON.stringify(data);
+    }
+    catch {
+        return '[unserializable]';
+    }
+}

package/dist-lib/lib/model-download-progress.d.ts

@@ -0,0 +1,22 @@
+export interface ModelProgressFrame {
+    type: string;
+    [key: string]: unknown;
+}
+export interface ProgressBytes {
+    downloaded: number;
+    total: number;
+    aggregate: boolean;
+}
+export interface TransferProgress extends ProgressBytes {
+    percentage: number;
+}
+export declare function transferProgress(event: Record<string, unknown>): TransferProgress | null;
+export declare function progressBytes(event: ModelProgressFrame): ProgressBytes;
+export declare class DownloadSpeedSampler {
+    private _downloaded;
+    private _at;
+    private _bytesPerSecond;
+    private _downloadKey;
+    sample(bytes: ProgressBytes, at: number, downloadKey: unknown): number;
+    private _reset;
+}

package/dist-lib/lib/model-download-progress.js

@@ -0,0 +1,95 @@
+const EMA_WEIGHT = 0.25;
+const STALL_MS = 2_000;
+const NO_BYTES = { downloaded: 0, total: 0, aggregate: false };
+export function transferProgress(event) {
+    const aggregate = aggregateTransfer(event.fileSetInfo) ?? aggregateTransfer(event.shardInfo);
+    if (aggregate)
+        return aggregate;
+    const bytes = { downloaded: uint(event.downloaded), total: uint(event.total), aggregate: false };
+    const reported = reportedPercentage(event.percentage);
+    if (reported === null && bytes.downloaded === 0 && bytes.total === 0)
+        return null;
+    return { ...bytes, percentage: resolvePercentage(reported, bytes) };
+}
+export function progressBytes(event) {
+    const transfer = transferProgress(event);
+    if (!transfer)
+        return NO_BYTES;
+    return {
+        downloaded: transfer.downloaded,
+        total: transfer.total,
+        aggregate: transfer.aggregate
+    };
+}
+export class DownloadSpeedSampler {
+    _downloaded = null;
+    _at = 0;
+    _bytesPerSecond = 0;
+    _downloadKey = null;
+    sample(bytes, at, downloadKey) {
+        const key = typeof downloadKey === 'string' ? downloadKey : null;
+        const keyChanged = !bytes.aggregate && this._downloaded !== null && key !== this._downloadKey;
+        if (this._downloaded === null || bytes.downloaded < this._downloaded || keyChanged) {
+            this._reset(bytes.downloaded, at, key);
+            return 0;
+        }
+        const elapsedMs = at - this._at;
+        if (elapsedMs <= 0)
+            return Math.round(this._bytesPerSecond);
+        const delta = bytes.downloaded - this._downloaded;
+        if (delta === 0) {
+            if (elapsedMs >= STALL_MS) {
+                this._bytesPerSecond = 0;
+                this._at = at;
+            }
+            return Math.round(this._bytesPerSecond);
+        }
+        this._downloaded = bytes.downloaded;
+        this._at = at;
+        this._downloadKey = key;
+        const measured = (delta * 1000) / elapsedMs;
+        this._bytesPerSecond =
+            this._bytesPerSecond > 0
+                ? EMA_WEIGHT * measured + (1 - EMA_WEIGHT) * this._bytesPerSecond
+                : measured;
+        return Math.max(0, Math.round(this._bytesPerSecond));
+    }
+    _reset(downloaded, at, downloadKey) {
+        this._downloaded = downloaded;
+        this._at = at;
+        this._bytesPerSecond = 0;
+        this._downloadKey = downloadKey;
+    }
+}
+function aggregateTransfer(value) {
+    if (!record(value))
+        return null;
+    const bytes = {
+        downloaded: uint(value.overallDownloaded),
+        total: uint(value.overallTotal),
+        aggregate: true
+    };
+    const reported = reportedPercentage(value.overallPercentage);
+    if (bytes.downloaded === 0 && bytes.total === 0) {
+        return reported !== null && reported > 0 ? { ...bytes, percentage: reported } : null;
+    }
+    return { ...bytes, percentage: resolvePercentage(reported, bytes) };
+}
+function resolvePercentage(reported, bytes) {
+    return reported !== null && reported > 0 ? reported : bytesPercentage(bytes);
+}
+function reportedPercentage(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? percentage(value) : null;
+}
+function bytesPercentage(bytes) {
+    return bytes.total > 0 ? percentage((bytes.downloaded / bytes.total) * 100) : 0;
+}
+function record(value) {
+    return typeof value === 'object' && value !== null;
+}
+function uint(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+function percentage(value) {
+    return Math.max(0, Math.min(100, Math.floor(value)));
+}

package/dist-lib/lib/models/context.d.ts

@@ -0,0 +1,5 @@
+import type { ModelRegistryEntry } from '@qvac/sdk';
+export type ModelSrc = string | (ModelRegistryEntry & {
+    src: string;
+});
+export declare function defaultContextSize(modelSrc: ModelSrc): number;

package/dist-lib/lib/models/context.js

@@ -0,0 +1,12 @@
+const TINY_MODEL_PARAMS_BILLIONS = 0.8;
+const TINY_MODEL_CONTEXT_SIZE = 8_192;
+const DESKTOP_DEFAULT_CONTEXT_SIZE = 51_200;
+export function defaultContextSize(modelSrc) {
+    if (typeof modelSrc === 'string')
+        return DESKTOP_DEFAULT_CONTEXT_SIZE;
+    const params = Number.parseFloat(modelSrc.params);
+    if (Number.isFinite(params) && params <= TINY_MODEL_PARAMS_BILLIONS) {
+        return TINY_MODEL_CONTEXT_SIZE;
+    }
+    return DESKTOP_DEFAULT_CONTEXT_SIZE;
+}

package/dist-lib/lib/models/embed-config.d.ts

@@ -0,0 +1,14 @@
+export type EmbedDevice = 'gpu' | 'cpu';
+export interface EmbedConfigInput {
+    device?: EmbedDevice;
+    gpuLayers?: number;
+    batchSize?: number;
+}
+export interface EmbedConfig {
+    readonly device: EmbedDevice;
+    readonly gpuLayers?: number | undefined;
+    readonly batchSize: number;
+}
+export declare const DEFAULT_EMBED_BATCH_SIZE = 1024;
+export declare function createEmbedConfig(input?: EmbedConfigInput): EmbedConfig;
+export declare function assertEmbedDevice(device: unknown): asserts device is EmbedDevice;

package/dist-lib/lib/models/embed-config.js

@@ -0,0 +1,31 @@
+export const DEFAULT_EMBED_BATCH_SIZE = 1024;
+export function createEmbedConfig(input = {}) {
+    assertOptionalEmbedDevice(input.device);
+    assertNonNegativeInteger('embedGpuLayers', input.gpuLayers);
+    assertPositiveInteger('embedBatchSize', input.batchSize);
+    return {
+        device: input.device ?? 'gpu',
+        gpuLayers: input.gpuLayers,
+        batchSize: input.batchSize ?? DEFAULT_EMBED_BATCH_SIZE
+    };
+}
+export function assertEmbedDevice(device) {
+    if (device === 'gpu' || device === 'cpu')
+        return;
+    throw new TypeError('embedDevice must be "gpu" or "cpu"');
+}
+function assertOptionalEmbedDevice(device) {
+    if (device === undefined)
+        return;
+    assertEmbedDevice(device);
+}
+function assertNonNegativeInteger(name, value) {
+    if (value === undefined || (Number.isInteger(value) && value >= 0))
+        return;
+    throw new TypeError(`${name} must be a non-negative integer`);
+}
+function assertPositiveInteger(name, value) {
+    if (value === undefined || (Number.isInteger(value) && value > 0))
+        return;
+    throw new TypeError(`${name} must be a positive integer`);
+}

package/dist-lib/lib/models/gpu-selection.d.ts

@@ -0,0 +1,3 @@
+export type MainGpuProbe = () => Promise<string | undefined>;
+export declare function resolveMainGpu(): Promise<string | undefined>;
+export declare function resetMainGpuCache(): void;

package/dist-lib/lib/models/gpu-selection.js

@@ -0,0 +1,26 @@
+import { promises } from 'fs';
+import { platform } from 'os';
+let cachedDedicated = null;
+export async function resolveMainGpu() {
+    if (platform() !== 'linux')
+        return undefined;
+    if (cachedDedicated !== null)
+        return cachedDedicated;
+    if (await hasNvidiaGpu()) {
+        cachedDedicated = 'dedicated';
+        return cachedDedicated;
+    }
+    return undefined;
+}
+export function resetMainGpuCache() {
+    cachedDedicated = null;
+}
+async function hasNvidiaGpu() {
+    try {
+        const entries = await promises.readdir('/proc/driver/nvidia/gpus');
+        return entries.length > 0;
+    }
+    catch {
+        return false;
+    }
+}

package/dist-lib/lib/models/kv-cache.d.ts

@@ -0,0 +1,4 @@
+export declare function adrenoSafeKvCache(device: 'cpu' | 'gpu' | undefined, requestedK: string | undefined, requestedV: string | undefined, hostPlatform?: string): {
+    k: string | undefined;
+    v: string | undefined;
+};

package/dist-lib/lib/models/kv-cache.js

@@ -0,0 +1,6 @@
+import { platform } from 'os';
+export function adrenoSafeKvCache(device, requestedK, requestedV, hostPlatform = platform()) {
+    if (device === 'cpu' || hostPlatform !== 'android')
+        return { k: requestedK, v: requestedV };
+    return { k: 'f16', v: 'f16' };
+}

package/dist-lib/lib/models/llm-presets.d.ts

@@ -0,0 +1,10 @@
+export type LlmGenerationParams = {
+    temp?: number;
+    top_p?: number;
+    top_k?: number;
+    presence_penalty?: number;
+    repeat_penalty?: number;
+    frequency_penalty?: number;
+    reasoning_budget: -1 | 0;
+};
+export declare function resolveLlmGenerationParams(modelName: string | undefined, reasoningEnabled: boolean | undefined, deviceDefault?: boolean): LlmGenerationParams | undefined;

package/dist-lib/lib/models/llm-presets.js

@@ -0,0 +1,58 @@
+const QWEN_NONTHINKING_VL_SAMPLER = {
+    temp: 0.7,
+    top_p: 0.8,
+    top_k: 20,
+    presence_penalty: 1.5,
+    repeat_penalty: 1.0,
+    frequency_penalty: 0
+};
+const QWEN_THINKING_VL_OR_CODING_SAMPLER = {
+    temp: 0.6,
+    top_p: 0.95,
+    top_k: 20,
+    presence_penalty: 0,
+    repeat_penalty: 1.0,
+    frequency_penalty: 0
+};
+const QWEN_THINKING_GENERAL_SAMPLER = {
+    temp: 1.0,
+    top_p: 0.95,
+    top_k: 20,
+    presence_penalty: 1.5,
+    repeat_penalty: 1.0,
+    frequency_penalty: 0
+};
+const PRESET_RESOLVERS = [
+    { prefix: 'Qwen3.5-0.8B-', resolve: qwen08BPreset },
+    { prefix: 'Qwen3.5-2B-', resolve: qwen2BPreset },
+    { prefix: 'Qwen3.5-4B-', resolve: qwen4BPreset }
+];
+export function resolveLlmGenerationParams(modelName, reasoningEnabled, deviceDefault) {
+    const resolver = modelName
+        ? PRESET_RESOLVERS.find((entry) => modelName.startsWith(entry.prefix))
+        : undefined;
+    if (resolver)
+        return resolver.resolve(reasoningEnabled);
+    const effective = reasoningEnabled ?? deviceDefault;
+    if (effective === undefined)
+        return undefined;
+    return { reasoning_budget: effective ? -1 : 0 };
+}
+function qwen08BPreset(reasoningEnabled) {
+    return reasoningEnabled === true ? thinkingVlPreset() : nonThinkingVlPreset();
+}
+function qwen2BPreset(reasoningEnabled) {
+    return reasoningEnabled === false ? nonThinkingVlPreset() : thinkingVlPreset();
+}
+function qwen4BPreset(reasoningEnabled) {
+    return reasoningEnabled === false ? nonThinkingVlPreset() : thinkingGeneralPreset();
+}
+function nonThinkingVlPreset() {
+    return { ...QWEN_NONTHINKING_VL_SAMPLER, reasoning_budget: 0 };
+}
+function thinkingVlPreset() {
+    return { ...QWEN_THINKING_VL_OR_CODING_SAMPLER, reasoning_budget: -1 };
+}
+function thinkingGeneralPreset() {
+    return { ...QWEN_THINKING_GENERAL_SAMPLER, reasoning_budget: -1 };
+}

package/dist-lib/lib/models/model-catalog-constants.d.ts

@@ -0,0 +1,29 @@
+export type CapabilityProfile = 'tiny' | 'low' | 'mid' | 'high' | 'xhigh';
+export declare const CAPABILITY_PROFILE_ORDER: readonly CapabilityProfile[];
+export declare const QWEN_35_2B = "Qwen3.5-2B-Q4_K_M";
+export declare const QWEN_35_4B = "Qwen3.5-4B-Q4_K_M";
+export declare const QWEN_35_9B = "Qwen3.5-9B-Q4_K_M";
+export declare const QWEN_36_27B = "Qwen3.6-27B-UD-Q4_K_XL";
+export declare const QWEN_36_35B_A3B = "Qwen3.6-35B-A3B-UD-Q4_K_M";
+export declare const QWEN_38_27B = "Qwen3.8-27B-UD-Q4_K_XL";
+export declare const MEDPSY_1_7B = "medpsy-1.7b-q4_k_m-imat";
+export declare const MEDPSY_4B = "medpsy-4b-q4_k_m-imat";
+export declare function isCapabilityProfile(value: string): value is CapabilityProfile;
+export declare function meetsMinCapabilityProfile(active: CapabilityProfile, required: CapabilityProfile): boolean;
+export declare function modelNameToCapabilityProfile(modelName: string): CapabilityProfile | undefined;
+export declare function capabilityProfileToModelName(profile: CapabilityProfile): string;
+export declare const AGENT_MODEL_NAMES: readonly ["Qwen3.5-2B-Q4_K_M", "Qwen3.5-4B-Q4_K_M", "Qwen3.5-9B-Q4_K_M", "Qwen3.6-27B-UD-Q4_K_XL", "Qwen3.6-35B-A3B-UD-Q4_K_M", "Qwen3.8-27B-UD-Q4_K_XL", "medpsy-1.7b-q4_k_m-imat", "medpsy-4b-q4_k_m-imat"];
+export declare function modelDisplayName(modelName: string): string;
+export declare function capabilityProfileModelLabel(profile: CapabilityProfile): string;
+export declare function isMultimodalLlm(modelName: string): boolean;
+export type ImageModelChoice = 'sd2' | 'sdxl' | 'flux2-klein';
+export declare const DEFAULT_IMAGE_MODEL_CHOICE: ImageModelChoice;
+export interface ImageChoiceEntry {
+    readonly choice: ImageModelChoice;
+    readonly label: string;
+    readonly requiresGpu: boolean;
+    readonly supportsMultiImageEdit: boolean;
+    readonly sizeBytesApprox: number;
+    readonly notes: string;
+}
+export declare const IMAGE_CHOICE_CATALOG: ReadonlyArray<ImageChoiceEntry>;