@qvac/harness 0.3.2 → 0.4.0

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

@@ -1,9 +1,11 @@
 import type { HarnessCapabilityProfile } from '../spec/hyperschema/types.d.ts';
 import type { ApproveFn, AskUserFn, AttachFn, FetchAttachmentFn, ProgressFn, RagSearchFn, ResourceDescriptor, ResponseFormat } from './capabilities/completion.ts';
 import type { KvCacheDeletionResult } from './capabilities/kv-cache.ts';
+import type { ModelSourcePreview, PreviewModelSourceContext } from './capabilities/preview-model-source.ts';
 import type { MemoryBudget } from './hardware/memory-budget.ts';
 import type { EmbedDevice } from './models/embed-config.ts';
 import type { LlmGenerationParams } from './models/llm-presets.ts';
+import type { CustomModelEntry } from './models/model-catalog.ts';
 import type { DeleteModelSummary } from './models/model-delete.ts';
 import type { ListModelsOptions, ModelInfo } from './models/model-list.ts';
 import type { ToolCatalogEntry } from './tools/catalog.ts';
@@ -219,11 +221,8 @@ export interface HarnessContract {
         name: string;
         addon: string;
     }>>;
-    setCustomModels?(entries: ReadonlyArray<{
-        name: string;
-        src: string;
-        projectionSrc?: string;
-    }>): void | Promise<void>;
+    setCustomModels?(entries: ReadonlyArray<CustomModelEntry>): void | Promise<void>;
+    previewModelSource?(context: PreviewModelSourceContext): Promise<ModelSourcePreview>;
     capability?(): Promise<CapabilityInfo>;
     diagnostics?(): HarnessDiagnostics;
 }

package/dist-lib/lib/models/custom-model-cache.d.ts

@@ -0,0 +1,4 @@
+import type { CustomModelEntry } from './model-catalog.ts';
+export declare function customFileCachePath(src: string, modelsDir: string | undefined): string | null;
+export declare function downloadedCustomFiles(entry: CustomModelEntry, modelsDir: string | undefined): string[];
+export declare function isCustomModelCached(entry: CustomModelEntry, modelsDir: string | undefined): Promise<boolean>;

package/dist-lib/lib/models/custom-model-cache.js

@@ -0,0 +1,42 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { isRemoteSource, localSourcePath } from './gguf-header.js';
+const SHARD = /-\d{5}-of-\d{5}\.\w+$/;
+const ARCHIVE = /\.(tar|tgz|zip)(\.\w+)?$/i;
+export function customFileCachePath(src, modelsDir) {
+    if (!isRemoteSource(src))
+        return localSourcePath(src);
+    const filename = src.split('/').pop()?.split('?')[0] || 'model.gguf';
+    if (!modelsDir || SHARD.test(filename) || ARCHIVE.test(filename))
+        return null;
+    const hash = crypto.createHash('sha256').update(src, 'utf8').digest('hex').slice(0, 16);
+    return path.join(modelsDir, `${hash}_${filename}`);
+}
+export function downloadedCustomFiles(entry, modelsDir) {
+    const srcs = entry.projectionSrc ? [entry.src, entry.projectionSrc] : [entry.src];
+    return srcs
+        .filter(isRemoteSource)
+        .map((src) => customFileCachePath(src, modelsDir))
+        .filter((file) => file !== null);
+}
+export async function isCustomModelCached(entry, modelsDir) {
+    const srcs = entry.projectionSrc ? [entry.src, entry.projectionSrc] : [entry.src];
+    const sizes = await Promise.all(srcs.map((src) => onDiskSize(customFileCachePath(src, modelsDir))));
+    const present = sizes.filter((size) => size !== null);
+    if (present.length < sizes.length)
+        return false;
+    const total = present.reduce((sum, size) => sum + size, 0);
+    return entry.expectedSize ? total === entry.expectedSize : true;
+}
+async function onDiskSize(file) {
+    if (file === null)
+        return null;
+    try {
+        const stat = await fs.promises.stat(file);
+        return stat.isFile() ? stat.size : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist-lib/lib/models/gguf-header.d.ts

@@ -0,0 +1,30 @@
+import { type AbortSignal } from 'bare-abort-controller';
+export interface GgufHeader {
+    readonly architecture?: string;
+    readonly name?: string;
+    readonly type?: string;
+    readonly license?: string;
+    readonly contextLength?: number;
+    readonly sizeLabel?: string;
+    readonly tags?: ReadonlyArray<string>;
+}
+export type GgufRangeFetch = (url: string, init: {
+    headers: Record<string, string>;
+    signal?: AbortSignal;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    headers: {
+        get(name: string): string | null;
+    };
+    arrayBuffer(): Promise<ArrayBuffer>;
+}>;
+export declare const GGUF_HEADER_BYTES = 1048576;
+export declare const GGUF_HEADER_TIMEOUT_MS = 30000;
+export declare function isRemoteSource(src: string): boolean;
+export declare function localSourcePath(src: string): string | null;
+export declare function readGgufHeaderBytes(src: string, opts?: {
+    fetch?: GgufRangeFetch;
+    maxBytes?: number;
+}): Promise<Uint8Array | null>;
+export declare function parseGgufHeader(bytes: Uint8Array): GgufHeader | null;

package/dist-lib/lib/models/gguf-header.js

@@ -0,0 +1,208 @@
+import b4a from 'b4a';
+import { AbortController } from 'bare-abort-controller';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import defaultFetch from '#fetch';
+export const GGUF_HEADER_BYTES = 1_048_576;
+export const GGUF_HEADER_TIMEOUT_MS = 30_000;
+const UINT8 = 0;
+const INT8 = 1;
+const UINT16 = 2;
+const INT16 = 3;
+const UINT32 = 4;
+const INT32 = 5;
+const FLOAT32 = 6;
+const BOOL = 7;
+const STRING = 8;
+const ARRAY = 9;
+const UINT64 = 10;
+const INT64 = 11;
+const FLOAT64 = 12;
+export function isRemoteSource(src) {
+    return /^https?:\/\//i.test(src);
+}
+export function localSourcePath(src) {
+    if (/^file:/i.test(src))
+        return filePath(src);
+    if (/^[a-z][a-z0-9+.-]+:/i.test(src))
+        return null;
+    if (src === '~')
+        return os.homedir();
+    if (src.startsWith('~/'))
+        return path.join(os.homedir(), src.slice(2));
+    return src;
+}
+function filePath(src) {
+    try {
+        return fileURLToPath(src);
+    }
+    catch {
+        return null;
+    }
+}
+export function readGgufHeaderBytes(src, opts = {}) {
+    const maxBytes = opts.maxBytes ?? GGUF_HEADER_BYTES;
+    return isRemoteSource(src)
+        ? fetchHead(src, maxBytes, opts.fetch ?? defaultFetch)
+        : readLocalHead(src, maxBytes);
+}
+async function fetchHead(src, maxBytes, fetch) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(undefined), GGUF_HEADER_TIMEOUT_MS);
+    try {
+        const response = await fetch(src, {
+            headers: { Range: `bytes=0-${maxBytes - 1}` },
+            signal: controller.signal
+        });
+        if (!response.ok)
+            return null;
+        const length = response.headers.get('content-length');
+        if (length === null || !(Number(length) <= maxBytes))
+            return null;
+        return new Uint8Array(await response.arrayBuffer()).subarray(0, maxBytes);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function readLocalHead(src, maxBytes) {
+    const file = localSourcePath(src);
+    if (file === null)
+        return null;
+    let handle;
+    try {
+        handle = await fs.promises.open(file, 'r');
+        const buffer = b4a.allocUnsafe(maxBytes);
+        const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+        return buffer.subarray(0, bytesRead);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+export function parseGgufHeader(bytes) {
+    if (bytes.byteLength < 24)
+        return null;
+    if (b4a.toString(bytes.subarray(0, 4), 'latin1') !== 'GGUF')
+        return null;
+    const c = {
+        view: new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength),
+        bytes,
+        offset: 16
+    };
+    if (c.view.getUint32(4, true) < 2)
+        return null;
+    const count = readU64(c);
+    const header = {};
+    const contextLengths = new Map();
+    for (let i = 0; i < count; i += 1) {
+        const key = readString(c);
+        if (key === null || !has(c, 4))
+            break;
+        const value = readValue(c, readU32(c), key === 'general.tags');
+        if (!value.ok)
+            break;
+        if (key === 'general.architecture')
+            header.architecture = value.str;
+        else if (key === 'general.name')
+            header.name = value.str;
+        else if (key === 'general.type')
+            header.type = value.str;
+        else if (key === 'general.license')
+            header.license = value.str;
+        else if (key === 'general.size_label')
+            header.sizeLabel = value.str;
+        else if (key === 'general.tags')
+            header.tags = value.strs;
+        else if (key.endsWith('.context_length'))
+            contextLengths.set(key, value.num);
+    }
+    header.contextLength =
+        contextLengths.get(`${header.architecture}.context_length`) ??
+            contextLengths.values().next().value;
+    return header;
+}
+function readValue(c, type, collect = false) {
+    switch (type) {
+        case UINT8:
+        case BOOL:
+            return fixed(c, 1, () => c.view.getUint8(c.offset));
+        case INT8:
+            return fixed(c, 1, () => c.view.getInt8(c.offset));
+        case UINT16:
+            return fixed(c, 2, () => c.view.getUint16(c.offset, true));
+        case INT16:
+            return fixed(c, 2, () => c.view.getInt16(c.offset, true));
+        case UINT32:
+            return fixed(c, 4, () => c.view.getUint32(c.offset, true));
+        case INT32:
+            return fixed(c, 4, () => c.view.getInt32(c.offset, true));
+        case FLOAT32:
+            return fixed(c, 4, () => c.view.getFloat32(c.offset, true));
+        case FLOAT64:
+            return fixed(c, 8, () => c.view.getFloat64(c.offset, true));
+        case UINT64:
+        case INT64:
+            return has(c, 8) ? { ok: true, num: readU64(c) } : { ok: false };
+        case STRING: {
+            const str = readString(c);
+            return str === null ? { ok: false } : { ok: true, str };
+        }
+        case ARRAY: {
+            if (!has(c, 12))
+                return { ok: false };
+            const elementType = readU32(c);
+            const length = readU64(c);
+            const strs = new Array();
+            for (let i = 0; i < length; i += 1) {
+                const element = readValue(c, elementType);
+                if (!element.ok)
+                    return { ok: false };
+                if (collect && element.str !== undefined)
+                    strs.push(element.str);
+            }
+            return collect ? { ok: true, strs } : { ok: true };
+        }
+        default:
+            return { ok: false };
+    }
+}
+function fixed(c, width, read) {
+    if (!has(c, width))
+        return { ok: false };
+    const num = read();
+    c.offset += width;
+    return { ok: true, num };
+}
+function has(c, n) {
+    return n >= 0 && c.offset + n <= c.bytes.byteLength;
+}
+function readU32(c) {
+    const value = c.view.getUint32(c.offset, true);
+    c.offset += 4;
+    return value;
+}
+function readU64(c) {
+    const lo = c.view.getUint32(c.offset, true);
+    const hi = c.view.getUint32(c.offset + 4, true);
+    c.offset += 8;
+    return hi * 2 ** 32 + lo;
+}
+function readString(c) {
+    if (!has(c, 8))
+        return null;
+    const length = readU64(c);
+    if (!has(c, length))
+        return null;
+    const str = b4a.toString(c.bytes.subarray(c.offset, c.offset + length), 'utf8');
+    c.offset += length;
+    return str;
+}

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

@@ -105,13 +105,18 @@ export interface CuratedListable {
 }
 export declare function curatedListables(): CuratedListable[];
 export declare function curatedModelAsset(name: string, addon: ModelRegistryEntry['addon']): SdkModelAsset | undefined;
+export declare const CUSTOM_TASK_TYPES: readonly ['llm'];
+export type CustomTaskType = (typeof CUSTOM_TASK_TYPES)[number];
 export interface CustomModelEntry {
     readonly name: string;
     readonly src: string;
     readonly projectionSrc?: string;
+    readonly taskType?: CustomTaskType;
+    readonly expectedSize?: number;
 }
 export declare function setCustomModels(entries: ReadonlyArray<CustomModelEntry>): void;
-export declare function customModelSrc(name: string): string | undefined;
+export declare function customModels(): ReadonlyArray<CustomModelEntry>;
+export declare function customModelSrc(name: string, addon: ModelRegistryEntry['addon']): string | undefined;
 export declare function customToolDialect(name: string): ToolDialect | undefined;
 export declare function customProjectionMap(): Record<string, string>;
 export declare function companionRegistryPaths(): Map<string, string[]>;

package/dist-lib/lib/models/model-catalog.js

@@ -311,12 +311,17 @@ export function curatedListables() {
 export function curatedModelAsset(name, addon) {
     return curatedListables().find((entry) => entry.asset.addon === addon && (entry.name === name || entry.asset.name === name))?.asset;
 }
+export const CUSTOM_TASK_TYPES = ['llm'];
 let CUSTOM_MODELS = new Map();
 export function setCustomModels(entries) {
     CUSTOM_MODELS = new Map(entries.map((entry) => [entry.name, entry]));
 }
-export function customModelSrc(name) {
-    return CUSTOM_MODELS.get(name)?.src;
+export function customModels() {
+    return [...CUSTOM_MODELS.values()];
+}
+export function customModelSrc(name, addon) {
+    const entry = CUSTOM_MODELS.get(name);
+    return entry && (entry.taskType ?? 'llm') === addon ? entry.src : undefined;
 }
 export function customToolDialect(name) {
     const entry = CUSTOM_MODELS.get(name);

package/dist-lib/lib/models/model-delete.d.ts

@@ -15,4 +15,7 @@ export interface DeleteModelSummary {
     readonly freedBytes: number;
 }
 export declare function summarizeDelete(result: DeleteModelResult): DeleteModelSummary;
-export declare function deleteModelFiles(sdk: ModelDeleteSdk, name: string): Promise<DeleteModelResult>;
+export interface DeleteModelOptions {
+    readonly modelsDir?: string;
+}
+export declare function deleteModelFiles(sdk: ModelDeleteSdk, name: string, { modelsDir }?: DeleteModelOptions): Promise<DeleteModelResult>;

package/dist-lib/lib/models/model-delete.js

@@ -1,27 +1,32 @@
 import fs from 'fs';
-import { curatedListables, musicListables } from './model-catalog.js';
+import { downloadedCustomFiles } from './custom-model-cache.js';
+import { curatedListables, customModels, musicListables } from './model-catalog.js';
 export function summarizeDelete(result) {
     return { name: result.name, removed: result.removed.length, freedBytes: result.freedBytes };
 }
-export async function deleteModelFiles(sdk, name) {
-    const seen = new Set();
+export async function deleteModelFiles(sdk, name, { modelsDir } = {}) {
+    const custom = customModels().find((entry) => entry.name === name);
+    const paths = custom ? downloadedCustomFiles(custom, modelsDir) : await catalogFiles(sdk, name);
     const removed = [];
+    for (const filePath of new Set(paths)) {
+        const bytes = await onDiskSize(filePath);
+        if (bytes === null)
+            continue;
+        await fs.promises.rm(filePath, { force: true });
+        removed.push({ path: filePath, bytes });
+    }
+    return { name, removed, freedBytes: removed.reduce((sum, file) => sum + file.bytes, 0) };
+}
+async function catalogFiles(sdk, name) {
+    const paths = [];
     for (const catalogName of namesToPurge(name)) {
         const info = await sdk.getModelInfo({ name: catalogName }).catch(() => null);
         if (!info)
             continue;
-        for (const file of info.cacheFiles) {
-            if (seen.has(file.path))
-                continue;
-            seen.add(file.path);
-            const bytes = await onDiskSize(file.path);
-            if (bytes === null)
-                continue;
-            await fs.promises.rm(file.path, { force: true });
-            removed.push({ path: file.path, bytes });
-        }
+        for (const file of info.cacheFiles)
+            paths.push(file.path);
     }
-    return { name, removed, freedBytes: removed.reduce((sum, file) => sum + file.bytes, 0) };
+    return paths;
 }
 async function onDiskSize(filePath) {
     try {

package/dist-lib/lib/models/model-list.d.ts

@@ -39,4 +39,10 @@ export declare const MODEL_STATUS_TTL_MS = 30000;
 export declare function createModelStatusCache(): ModelStatusCache;
 export declare function invalidateModelStatusCache(cache: ModelStatusCache): void;
 export declare function listModels(sdk: ModelListSdk, { type, cachedOnly, fullRegistry }?: ListModelsOptions, cache?: ModelStatusCache, projectionFor?: (name: string) => string | undefined): Promise<ModelInfo[]>;
+export interface CustomModelRowsContext {
+    readonly modelsDir?: string;
+    readonly loaded: ReadonlySet<string>;
+}
+export declare function customModelRows({ type, cachedOnly }: ListModelsOptions, { modelsDir, loaded }: CustomModelRowsContext): Promise<ModelInfo[]>;
+export declare function mergeCustomRows(catalog: ReadonlyArray<ModelInfo>, custom: ReadonlyArray<ModelInfo>): ModelInfo[];
 export {};

package/dist-lib/lib/models/model-list.js

@@ -1,4 +1,5 @@
-import { companionRegistryPaths, curatedListables, musicListables } from './model-catalog.js';
+import { isCustomModelCached } from './custom-model-cache.js';
+import { companionRegistryPaths, curatedListables, customModels, musicListables } from './model-catalog.js';
 export const MODEL_STATUS_TTL_MS = 30_000;
 export function createModelStatusCache() {
     return { entries: new Map(), epoch: 0 };
@@ -121,3 +122,24 @@ export async function listModels(sdk, { type, cachedOnly, fullRegistry } = {}, c
     });
     return cachedOnly ? rows.filter((row) => row.isCached) : rows;
 }
+export async function customModelRows({ type, cachedOnly }, { modelsDir, loaded }) {
+    const entries = customModels().filter((entry) => !type || (entry.taskType ?? 'llm') === type);
+    const rows = await Promise.all(entries.map(async (entry) => {
+        const addon = entry.taskType ?? 'llm';
+        return {
+            name: entry.name,
+            type: addon,
+            registryPath: entry.src,
+            registrySource: 'custom',
+            isCached: await isCustomModelCached(entry, modelsDir),
+            isLoaded: loaded.has(entry.name),
+            supportsImages: addon === 'llm' && Boolean(entry.projectionSrc),
+            expectedSize: entry.expectedSize ?? 0
+        };
+    }));
+    return cachedOnly ? rows.filter((row) => row.isCached) : rows;
+}
+export function mergeCustomRows(catalog, custom) {
+    const shadowed = new Set(custom.map((row) => row.name));
+    return [...catalog.filter((row) => !shadowed.has(row.name)), ...custom];
+}

package/dist-lib/lib/models/model-source.js

@@ -2,7 +2,7 @@ import { audioGenModelByName, curatedModelAsset, customModelSrc } from './model-
 export async function resolveModelSrc(sdk, model, addon = 'llm') {
     if (/^(\/|~|\.|file:|https?:|registry:|pear:|hyper:)/.test(model))
         return model;
-    const custom = customModelSrc(model);
+    const custom = customModelSrc(model, addon);
     if (custom)
         return custom;
     if (addon === 'audiogen') {

package/dist-lib/lib/serve.js

@@ -5,6 +5,7 @@ import { pipeline, Readable } from 'streamx';
 import { bindApi } from '../spec/bind.js';
 import HRPC from '../spec/hrpc/index.js';
 import { isCapability } from './capabilities/invoke.js';
+import { CUSTOM_TASK_TYPES } from './models/model-catalog.js';
 import { unsupportedKvCacheDeletion } from './capabilities/kv-cache.js';
 import { errorMessage } from './error-fields.js';
 import { hlog } from './log.js';
@@ -65,13 +66,28 @@ export function serveHarness(stream, harness) {
             removed: (await harness.deleteOverlaySkill?.(name))?.removed ?? false
         }),
         setCustomModels: async ({ models }) => {
-            await harness.setCustomModels?.((models ?? []).map(({ name, src, projectionSrc }) => ({
-                name,
-                src,
-                projectionSrc: projectionSrc ?? undefined
-            })));
+            await harness.setCustomModels?.((models ?? []).flatMap(({ name, src, projectionSrc, taskType, expectedSize }) => {
+                const known = CUSTOM_TASK_TYPES.find((task) => task === taskType);
+                if (taskType && !known)
+                    return [];
+                return [
+                    {
+                        name,
+                        src,
+                        projectionSrc: projectionSrc ?? undefined,
+                        taskType: known,
+                        expectedSize: expectedSize || undefined
+                    }
+                ];
+            }));
             return { ok: true };
         },
+        previewModelSource: async ({ src, mmprojSrc }) => {
+            if (!harness.previewModelSource) {
+                throw new Error('harness does not support previewModelSource');
+            }
+            return harness.previewModelSource({ src: src ?? '', mmprojSrc: mmprojSrc ?? undefined });
+        },
         describe: async () => (await harness.describe?.()) ?? {
             toolNames: [],
             skills: [],

package/dist-lib/schema/harness.js

@@ -564,7 +564,9 @@ export function registerHarnessTypes(ns) {
         fields: [
             { name: 'name', type: 'string', required: true },
             { name: 'src', type: 'string', required: true },
-            { name: 'projectionSrc', type: 'string' }
+            { name: 'projectionSrc', type: 'string' },
+            { name: 'taskType', type: 'string' },
+            { name: 'expectedSize', type: 'uint' }
         ]
     });
     ns.register({
@@ -678,6 +680,40 @@ export function registerHarnessTypes(ns) {
             { name: 'verify', type: '@harness/skill-oauth-verify' }
         ]
     });
+    ns.register({
+        name: 'preview-model-source-request',
+        fields: [
+            { name: 'src', type: 'string', required: true },
+            { name: 'mmprojSrc', type: 'string' }
+        ]
+    });
+    ns.register({
+        name: 'model-source-file',
+        fields: [
+            { name: 'src', type: 'string', required: true },
+            { name: 'label', type: 'string', required: true },
+            { name: 'sizeBytes', type: 'uint' }
+        ]
+    });
+    ns.register({
+        name: 'preview-model-source-response',
+        fields: [
+            { name: 'ok', type: 'bool', required: true },
+            { name: 'refusal', type: 'string' },
+            { name: 'reason', type: 'string' },
+            { name: 'src', type: 'string' },
+            { name: 'files', type: '@harness/model-source-file', array: true },
+            { name: 'sizeBytes', type: 'uint' },
+            { name: 'contextLength', type: 'uint' },
+            { name: 'architecture', type: 'string' },
+            { name: 'sizeLabel', type: 'string' },
+            { name: 'taskType', type: 'string' },
+            { name: 'license', type: 'string' },
+            { name: 'fit', type: 'string' },
+            { name: 'fitReasons', type: 'string', array: true },
+            { name: 'mmprojSrc', type: 'string' }
+        ]
+    });
 }
 export function registerHarnessApi(api) {
     api.register({
@@ -825,4 +861,9 @@ export function registerHarnessApi(api) {
         request: { name: '@harness/detect-language-request', stream: false },
         response: { name: '@harness/detect-language-response', stream: false }
     });
+    api.register({
+        name: 'preview-model-source',
+        request: { name: '@harness/preview-model-source-request', stream: false },
+        response: { name: '@harness/preview-model-source-response', stream: false }
+    });
 }

package/dist-lib/spec/bind.js

@@ -127,4 +127,7 @@ export function bindApi(rpc, api) {
   if (api.detectLanguage) {
     rpc.onDetectLanguage((req) => api.detectLanguage(req));
   }
+  if (api.previewModelSource) {
+    rpc.onPreviewModelSource((req) => api.previewModelSource(req));
+  }
 }

package/dist-lib/spec/calls.js

@@ -39,5 +39,6 @@ export function harnessClient(rpc) {
     deleteOverlaySkill: (input) => rpc.deleteOverlaySkill(input),
     deleteKvCache: (input) => rpc.deleteKvCache(input),
     detectLanguage: (input) => rpc.detectLanguage(input),
+    previewModelSource: (input) => rpc.previewModelSource(input),
   };
 }

package/dist-lib/spec/hrpc/hrpc.json

@@ -377,6 +377,19 @@
         "stream": false
       },
       "version": 1
+    },
+    {
+      "id": 29,
+      "name": "@harness/preview-model-source",
+      "request": {
+        "name": "@harness/preview-model-source-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@harness/preview-model-source-response",
+        "stream": false
+      },
+      "version": 1
     }
   ]
 }

package/dist-lib/spec/hrpc/index.js

@@ -63,7 +63,9 @@ const methods = new Map([
   ['@harness/delete-kv-cache', 27],
   [27, '@harness/delete-kv-cache'],
   ['@harness/detect-language', 28],
-  [28, '@harness/detect-language']
+  [28, '@harness/detect-language'],
+  ['@harness/preview-model-source', 29],
+  [29, '@harness/preview-model-source']
 ])
 
 class HRPC {
@@ -99,7 +101,8 @@ class HRPC {
       ['@harness/copy-skill-for-edit', getEncoding('@harness/skill-name-request')],
       ['@harness/delete-overlay-skill', getEncoding('@harness/skill-name-request')],
       ['@harness/delete-kv-cache', getEncoding('@harness/kv-cache-delete-request')],
-      ['@harness/detect-language', getEncoding('@harness/detect-language-request')]
+      ['@harness/detect-language', getEncoding('@harness/detect-language-request')],
+      ['@harness/preview-model-source', getEncoding('@harness/preview-model-source-request')]
     ])
     this._responseEncodings = new Map([
       ['@harness/completion', getEncoding('@harness/completion-event')],
@@ -130,7 +133,8 @@ class HRPC {
       ['@harness/copy-skill-for-edit', getEncoding('@harness/copy-skill-response')],
       ['@harness/delete-overlay-skill', getEncoding('@harness/delete-skill-response')],
       ['@harness/delete-kv-cache', getEncoding('@harness/kv-cache-deletion-response')],
-      ['@harness/detect-language', getEncoding('@harness/detect-language-response')]
+      ['@harness/detect-language', getEncoding('@harness/detect-language-response')],
+      ['@harness/preview-model-source', getEncoding('@harness/preview-model-source-response')]
     ])
     this._rpc = new RPC(stream, async (req) => {
       const command = methods.get(req.command)
@@ -344,6 +348,10 @@ class HRPC {
     return this._call('@harness/detect-language', args)
   }
 
+  async previewModelSource(args) {
+    return this._call('@harness/preview-model-source', args)
+  }
+
   onCompletion(responseFn) {
     this._handlers['@harness/completion'] = responseFn
   }
@@ -460,6 +468,10 @@ class HRPC {
     this._handlers['@harness/detect-language'] = responseFn
   }
 
+  onPreviewModelSource(responseFn) {
+    this._handlers['@harness/preview-model-source'] = responseFn
+  }
+
   _requestIsStream(command) {
     return [
       '@harness/completion',