@qvac/harness 0.8.5 → 0.8.7

package/dist-lib/lib/capabilities/voice.js

@@ -2,6 +2,7 @@ import b4a from 'b4a';
 import { errorMessage } from '../guards.js';
 import { AbortedError } from '../helpers/race-abort.js';
 import { hlog } from '../log.js';
+import { buildWavBuffer } from '../wav-encode.js';
 import { normalizeForSpeech } from './speech-text.js';
 export const SUPERTONIC_SAMPLE_RATE = 44100;
 export function createVoiceLane() {
@@ -14,31 +15,19 @@ export function createVoiceLane() {
 }
 const TRANSCRIBE_SAMPLE_RATE = 16000;
 const TRANSCRIBE_CHUNK_BYTES = TRANSCRIBE_SAMPLE_RATE * 2;
+const TRANSCRIBE_STREAM_MIN_BYTES = TRANSCRIBE_CHUNK_BYTES * 60;
+const TRANSCRIBE_SEGMENT_SECONDS = 300;
 const PARAKEET_STREAMING = { emitPartials: false, chunkMs: 5000 };
 const TRANSCRIBE_WITH_METADATA = false;
 const TRANSCRIBE_PACE_MS = 40;
 function pace(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const TRANSCRIBE_DRAIN_IDLE_MS = 3000;
-const TRANSCRIBE_DRAIN_MAX_MS = 60_000;
-async function writePaced(session, data, signal) {
-    for (let offset = 0; offset < data.length; offset += TRANSCRIBE_CHUNK_BYTES) {
+async function writePaced(session, pcm, signal) {
+    for await (const second of pcm) {
         if (signal?.aborted)
             return;
-        session.write(data.subarray(offset, offset + TRANSCRIBE_CHUNK_BYTES));
-        await pace(TRANSCRIBE_PACE_MS);
-    }
-}
-async function drainUntilIdle(lastPieceAt, streamClosed, signal) {
-    const deadline = Date.now() + TRANSCRIBE_DRAIN_MAX_MS;
-    for (;;) {
-        if (signal?.aborted || streamClosed() || Date.now() >= deadline)
-            return;
-        const last = lastPieceAt();
-        if (last > 0 && Date.now() - last >= TRANSCRIBE_DRAIN_IDLE_MS) {
-            return;
-        }
+        session.write(second);
         await pace(TRANSCRIBE_PACE_MS);
     }
 }
@@ -59,7 +48,93 @@ function transcribePiece(piece) {
     }
     return null;
 }
-export async function transcribeStreaming(sdk, pcm, { modelId, signal }) {
+async function* inSeconds(pcm) {
+    let pending = [];
+    let size = 0;
+    for await (const chunk of pcm) {
+        pending.push(chunk);
+        size += chunk.length;
+        if (size < TRANSCRIBE_CHUNK_BYTES) {
+            continue;
+        }
+        const joined = pending.length === 1 ? chunk : b4a.concat(pending);
+        let offset = 0;
+        for (; joined.length - offset >= TRANSCRIBE_CHUNK_BYTES; offset += TRANSCRIBE_CHUNK_BYTES) {
+            yield joined.subarray(offset, offset + TRANSCRIBE_CHUNK_BYTES);
+        }
+        size = joined.length - offset;
+        pending = size > 0 ? [joined.subarray(offset)] : [];
+    }
+    if (size > 0) {
+        yield b4a.concat(pending);
+    }
+}
+async function readHead(seconds, signal) {
+    const head = { seconds: [], bytes: 0 };
+    try {
+        while (head.bytes < TRANSCRIBE_STREAM_MIN_BYTES && !signal?.aborted) {
+            const next = await seconds.next();
+            if (next.done) {
+                break;
+            }
+            head.seconds.push(next.value);
+            head.bytes += next.value.length;
+        }
+    }
+    catch (err) {
+        hlog('audio decode/resample failed', { error: errorMessage(err) });
+        return null;
+    }
+    return head;
+}
+async function* resume(head, rest) {
+    yield* head.seconds;
+    yield* { [Symbol.asyncIterator]: () => rest };
+}
+export async function transcribeAudio(sdk, pcm, { modelId, signal, audio }) {
+    const seconds = inSeconds(pcm);
+    const head = await readHead(seconds, signal);
+    if (signal?.aborted) {
+        await seconds.return(undefined);
+        throw new AbortedError();
+    }
+    if (!head || head.bytes === 0) {
+        return transcribeOnce(sdk, modelId, audio);
+    }
+    if (head.bytes < TRANSCRIBE_STREAM_MIN_BYTES) {
+        return transcribeOnce(sdk, modelId, buildWavBuffer(b4a.concat(head.seconds)));
+    }
+    try {
+        return await transcribeStreaming(sdk, resume(head, seconds), { modelId, signal });
+    }
+    finally {
+        await seconds.return(undefined);
+    }
+}
+async function* segment(first, rest) {
+    yield first;
+    for (let n = 1; n < TRANSCRIBE_SEGMENT_SECONDS; n++) {
+        const next = await rest.next();
+        if (next.done) {
+            return;
+        }
+        yield next.value;
+    }
+}
+export async function transcribeStreaming(sdk, pcm, opts) {
+    const seconds = pcm[Symbol.asyncIterator]();
+    const parts = [];
+    try {
+        for (let first = await seconds.next(); !first.done; first = await seconds.next()) {
+            parts.push(await transcribeSession(sdk, segment(first.value, seconds), opts));
+        }
+    }
+    finally {
+        await seconds.return?.();
+    }
+    return parts.filter(Boolean).join(' ');
+}
+async function transcribeSession(sdk, pcm, { modelId, signal }) {
     const session = await sdk.transcribeStream({
         modelId,
         metadata: TRANSCRIBE_WITH_METADATA,
@@ -67,27 +142,20 @@ export async function transcribeStreaming(sdk, pcm, { modelId, signal }) {
     });
     const onAbort = () => session.destroy();
     signal?.addEventListener('abort', onAbort, { once: true });
-    let lastPieceAt = 0;
-    let streamClosed = false;
     const collect = (async () => {
         let out = '';
         for await (const piece of session) {
-            lastPieceAt = Date.now();
             const seg = transcribePiece(piece);
             if (!seg) {
                 continue;
             }
             out += !out || seg.append ? seg.text : ` ${seg.text}`;
         }
-        streamClosed = true;
         return out.replace(/\s+/g, ' ').trim();
     })();
-    collect.catch(() => {
-        streamClosed = true;
-    });
+    collect.catch(noop);
     try {
         await writePaced(session, pcm, signal);
-        await drainUntilIdle(() => lastPieceAt, () => streamClosed, signal);
         if (!signal?.aborted) {
             session.end();
         }

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

@@ -3,7 +3,7 @@ import { type Transport } from './rpc-session.ts';
 import { type KvCacheDeletionResult } from './capabilities/kv-cache.ts';
 import type { CustomModelEntry } from './models/model-catalog.ts';
 import { type ModelSourcePreview, type PreviewModelSourceContext } from './capabilities/preview-model-source.ts';
-import type { CapabilityInfo, CompletionContext, CredentialEntry, DetectedLanguage, DetectLanguageContext, DownloadContext, EmbedContext, HarnessContract, HarnessDiagnostics, HarnessEvent, HarnessInfo, InfraModel, InvokeContext, ListModelsOptions, ModelInfo, ResolvedSkillCatalogEntry, SkillsOptions, SkillWriteResult, SpeakContext, SpeakResult, SpeakStreamContext, ToolCatalogEntry, TranscribeContext, LoadModelContext, LoadModelResult, UnloadModelContext, UnloadModelResult, WarmModelContext } from './contract-types.ts';
+import type { CapabilityInfo, CompletionContext, CredentialEntry, DetectedLanguage, DetectLanguageContext, DownloadContext, EmbedContext, HarnessContract, HarnessDiagnostics, HarnessEvent, HarnessInfo, InfraModel, InvokeContext, ListModelsOptions, ModelInfo, ResolvedSkillCatalogEntry, SkillsOptions, SkillWriteResult, SpeakContext, SpeakResult, SpeakStreamContext, ToolCatalogEntry, TranscribeContext, LoadModelContext, LoadModelResult, MemoryUsage, UnloadModelContext, UnloadModelResult, WarmModelContext, DownloadsAllowedOptions } from './contract-types.ts';
 import { type EmbedDevice } from './models/embed-config.ts';
 import type { DeleteModelSummary } from './models/model-delete.ts';
 import type { CopyBaseResult, DeleteOverlayResult, ManagedSkill, SkillFileContent } from './tools/skills/overlay-crud.ts';
@@ -36,6 +36,9 @@ export declare class RemoteHarness extends EventEmitter implements HarnessContra
     setCredentials(entries: ReadonlyArray<CredentialEntry>): Promise<void>;
     setSkillSettings(entries: ReadonlyArray<SkillSettingEntry>): Promise<void>;
     setModelIdleTimeout(ms: number): Promise<void>;
+    setModelMemoryCap(percent: number): Promise<void>;
+    memoryUsage(): Promise<MemoryUsage>;
+    setDownloadsAllowed({ allowed }: DownloadsAllowedOptions): Promise<void>;
     listManagedSkills(): Promise<ManagedSkill[]>;
     readSkillFile(name: string): Promise<SkillFileContent | null>;
     writeSkillFile(name: string, content: string): Promise<SkillWriteResult>;

package/dist-lib/lib/connect.js

@@ -102,6 +102,7 @@ export class RemoteHarness extends EventEmitter {
             model: context.model,
             agent: knobs(context.agent),
             cacheKey: context.cacheKey,
+            session: context.session,
             thinkingDefault: context.thinkingDefault,
             generationParams: context.generationParams,
             responseFormat: context.responseFormat,
@@ -111,6 +112,7 @@ export class RemoteHarness extends EventEmitter {
                 content,
                 attachments: attachments?.map(({ path: file }) => ({ path: file }))
             })),
+            payload: { typedText: context.typedText },
             toolConfigs: context.toolConfigs,
             grantedDirs: context.grantedDirs,
             grantedDrives: context.grantedDrives,
@@ -422,6 +424,18 @@ export class RemoteHarness extends EventEmitter {
         const { client } = await this._ensure();
         await client.setModelIdleTimeout({ ms });
     }
+    async setModelMemoryCap(percent) {
+        const { client } = await this._ensure();
+        await client.setModelMemoryCap({ percent });
+    }
+    async memoryUsage() {
+        const { client } = await this._ensure();
+        return await client.memoryUsage({});
+    }
+    async setDownloadsAllowed({ allowed }) {
+        const { client } = await this._ensure();
+        await client.setDownloadsAllowed({ allowed });
+    }
     async listManagedSkills() {
         const { client } = await this._ensure();
         const response = await client.listManagedSkills({});
@@ -566,10 +580,11 @@ export class RemoteHarness extends EventEmitter {
             cachedOnly: options.cachedOnly,
             fullRegistry: options.fullRegistry
         });
-        return (response.models ?? []).map(({ actualSize, label, ...row }) => ({
+        return (response.models ?? []).map(({ actualSize, label, memoryBytes, ...row }) => ({
             ...row,
             actualSize: actualSize || undefined,
             label: label || undefined,
+            memoryBytes: memoryBytes || undefined,
             taskType: addonTaskType(row.type)
         }));
     }

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

@@ -46,7 +46,9 @@ export interface CompletionContext {
     model: string;
     agent: AgentKnobs;
     messages: ChatMessage[];
+    typedText?: string;
     cacheKey?: string;
+    session?: string;
     thinkingDefault?: string;
     toolConfigs?: Record<string, Record<string, unknown>>;
     generationParams?: LlmGenerationParams;
@@ -95,6 +97,9 @@ export interface HarnessEvent {
     message?: string;
     [key: string]: unknown;
 }
+export interface DownloadsAllowedOptions {
+    allowed: boolean;
+}
 export interface ModelState {
     status: string;
     model?: string;
@@ -107,6 +112,7 @@ export interface ModelState {
         model: string;
         refs: number;
     }>;
+    addon?: string | null;
 }
 export interface WarmModelContext {
     model: string;
@@ -118,6 +124,9 @@ export interface LoadModelResult {
     loaded: boolean;
     reason?: 'memory';
 }
+export interface MemoryUsage {
+    readonly usedBytes: number;
+}
 export interface UnloadModelContext {
     model: string;
 }
@@ -223,6 +232,9 @@ export interface HarnessContract {
         agentId?: string | null;
     }>): void | Promise<void>;
     setModelIdleTimeout?(ms: number): void | Promise<void>;
+    setModelMemoryCap?(percent: number): void | Promise<void>;
+    memoryUsage?(): Promise<MemoryUsage>;
+    setDownloadsAllowed?(options: DownloadsAllowedOptions): void | Promise<void>;
     listManagedSkills?(): Promise<ManagedSkill[]>;
     readSkillFile?(name: string): Promise<SkillFileContent | null>;
     writeSkillFile?(name: string, content: string): Promise<{

package/dist-lib/lib/helpers/tool-call-markup.d.ts

@@ -9,6 +9,7 @@ export declare function clipRawCall(raw: string): string;
 export interface KnownTool {
     readonly name: string;
 }
+export declare function hasMarkupCall(text: string): boolean;
 export declare function recoverMarkupToolCalls(text: string, knownTools: ReadonlyArray<KnownTool>): RecoveredToolCall[];
 export declare function stripToolCallMarkup(text: string): string;
 export declare function stripToolResponseBlocks(text: string): string;

package/dist-lib/lib/helpers/tool-call-markup.js

@@ -46,6 +46,9 @@ export const MAX_RAW_CALL_CHARS = 4096;
 export function clipRawCall(raw) {
     return raw.length > MAX_RAW_CALL_CHARS ? raw.slice(0, MAX_RAW_CALL_CHARS) : raw;
 }
+export function hasMarkupCall(text) {
+    return !markupBlocks(text, FUNCTION_OPEN, FUNCTION_CLOSE).next().done;
+}
 export function recoverMarkupToolCalls(text, knownTools) {
     const known = new Set(knownTools.map((tool) => tool.name));
     const calls = [];

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

@@ -0,0 +1,15 @@
+import type { CapabilityProfile } from './model-catalog-constants.ts';
+export interface ContextAsk {
+    trained(): Promise<number | undefined>;
+    fits(ctxSize: number): Promise<boolean>;
+}
+export declare class ContextChoice {
+    private readonly _profile;
+    private readonly _pending;
+    private readonly _chosen;
+    constructor(profile: () => Promise<CapabilityProfile | undefined>);
+    static ceiling(profile: CapabilityProfile | undefined): number | undefined;
+    chosen(key: string): number | undefined;
+    choose(key: string, tier: number, ask: ContextAsk): Promise<number>;
+    private _climb;
+}

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

@@ -0,0 +1,55 @@
+const RUNGS = [262_144, 131_072, 65_536];
+const CEILINGS = {
+    mid: 65_536,
+    high: 131_072,
+    xhigh: 262_144
+};
+export class ContextChoice {
+    _profile;
+    _pending = new Map();
+    _chosen = new Map();
+    constructor(profile) {
+        this._profile = profile;
+    }
+    static ceiling(profile) {
+        return profile && CEILINGS[profile];
+    }
+    chosen(key) {
+        return this._chosen.get(key);
+    }
+    choose(key, tier, ask) {
+        const pending = this._pending.get(key);
+        if (pending) {
+            return pending;
+        }
+        const choice = this._climb(tier, ask).then((ctxSize) => {
+            if (ctxSize === undefined) {
+                this._pending.delete(key);
+                return tier;
+            }
+            this._chosen.set(key, ctxSize);
+            return ctxSize;
+        });
+        this._pending.set(key, choice);
+        return choice;
+    }
+    async _climb(tier, ask) {
+        const ceiling = ContextChoice.ceiling(await this._profile());
+        if (!ceiling || ceiling <= tier) {
+            return tier;
+        }
+        const trained = await ask.trained();
+        if (!trained) {
+            return undefined;
+        }
+        for (const rung of RUNGS) {
+            if (rung > ceiling || rung > trained || rung <= tier) {
+                continue;
+            }
+            if (await ask.fits(rung)) {
+                return rung;
+            }
+        }
+        return tier;
+    }
+}

package/dist-lib/lib/models/download-gate.d.ts

@@ -0,0 +1,20 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { ModelAddon } from './model-source.ts';
+export interface HeldModel {
+    readonly model: string;
+    readonly addon: ModelAddon;
+}
+export interface DownloadGateOptions {
+    isCached(model: string, addon: ModelAddon): Promise<boolean>;
+    onHeld(held: HeldModel): void;
+    onDropped(held: HeldModel): void;
+}
+export type HoldFn = (model: string, addon: ModelAddon, signal?: BareAbortSignal) => Promise<void>;
+export interface DownloadGate {
+    readonly allowed: boolean;
+    setAllowed(allowed: boolean): void;
+    downloaded(): void;
+    hold: HoldFn;
+    abandon(): void;
+}
+export declare function createDownloadGate({ isCached, onHeld, onDropped }: DownloadGateOptions): DownloadGate;

package/dist-lib/lib/models/download-gate.js

@@ -0,0 +1,73 @@
+import { AbortedError, raceAbort } from '../helpers/race-abort.js';
+function deferred() {
+    const next = Promise.withResolvers();
+    next.promise.catch(noop);
+    return next;
+}
+export function createDownloadGate({ isCached, onHeld, onDropped }) {
+    let allowed = true;
+    let woke = deferred();
+    let dropped = deferred();
+    const wake = () => {
+        const woken = woke;
+        woke = deferred();
+        woken.resolve();
+    };
+    const wait = async (held, signal, onWait) => {
+        const drop = dropped;
+        const cancelled = () => signal?.aborted === true || drop !== dropped;
+        for (;;) {
+            const change = Promise.race([raceAbort(woke.promise, signal), drop.promise]);
+            change.catch(noop);
+            const ready = allowed || (await isCached(held.model, held.addon).catch(() => false));
+            if (cancelled()) {
+                throw new AbortedError();
+            }
+            if (ready) {
+                return;
+            }
+            onWait();
+            await change;
+        }
+    };
+    return {
+        get allowed() {
+            return allowed;
+        },
+        setAllowed(next) {
+            allowed = next;
+            if (allowed) {
+                wake();
+            }
+        },
+        downloaded: wake,
+        async hold(model, addon, signal) {
+            if (allowed)
+                return;
+            if (signal?.aborted)
+                throw new AbortedError();
+            const held = { model, addon };
+            let shown = false;
+            try {
+                await wait(held, signal, () => {
+                    if (!shown) {
+                        shown = true;
+                        onHeld(held);
+                    }
+                });
+            }
+            catch (err) {
+                if (shown) {
+                    onDropped(held);
+                }
+                throw err;
+            }
+        },
+        abandon() {
+            const abandoned = dropped;
+            dropped = deferred();
+            abandoned.reject(new AbortedError());
+        }
+    };
+}
+function noop() { }

package/dist-lib/lib/models/memory-cap.d.ts

@@ -0,0 +1,13 @@
+export declare const VictimRank: {
+    readonly generator: 0;
+    readonly companion: 1;
+    readonly requested: 2;
+    readonly pinned: 3;
+    readonly replying: 4;
+};
+export interface CapVictim {
+    readonly rank: number;
+    readonly lastUsed: number;
+}
+export declare function nextVictim<T extends CapVictim>(victims: ReadonlyArray<T>): T | undefined;
+export declare function memoryCapBytes(percent: number, availableBytes: number): number;

package/dist-lib/lib/models/memory-cap.js

@@ -0,0 +1,21 @@
+export const VictimRank = {
+    generator: 0,
+    companion: 1,
+    requested: 2,
+    pinned: 3,
+    replying: 4
+};
+export function nextVictim(victims) {
+    let best;
+    for (const victim of victims) {
+        if (best === undefined ||
+            victim.rank < best.rank ||
+            (victim.rank === best.rank && victim.lastUsed < best.lastUsed)) {
+            best = victim;
+        }
+    }
+    return best;
+}
+export function memoryCapBytes(percent, availableBytes) {
+    return Math.round((Math.min(percent, 100) / 100) * availableBytes);
+}

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

@@ -6,6 +6,8 @@ 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 BONSAI_2_27B_PQ2 = "Ternary-Bonsai-2-27B-PQ2_0";
+export declare const BONSAI_2_27B_PTQ1 = "Ternary-Bonsai-2-27B-PTQ1_0";
 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;
@@ -19,7 +21,7 @@ export interface HostCapability {
 export declare function isMobilePlatform(platform: string): boolean;
 export declare function runnableModelName(requested: string, host: HostCapability | null): string;
 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 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", "Ternary-Bonsai-2-27B-PQ2_0", "Ternary-Bonsai-2-27B-PTQ1_0", "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;

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

@@ -11,6 +11,8 @@ export const QWEN_35_9B = 'Qwen3.5-9B-Q4_K_M';
 export const QWEN_36_27B = 'Qwen3.6-27B-UD-Q4_K_XL';
 export const QWEN_36_35B_A3B = 'Qwen3.6-35B-A3B-UD-Q4_K_M';
 export const QWEN_38_27B = 'Qwen3.8-27B-UD-Q4_K_XL';
+export const BONSAI_2_27B_PQ2 = 'Ternary-Bonsai-2-27B-PQ2_0';
+export const BONSAI_2_27B_PTQ1 = 'Ternary-Bonsai-2-27B-PTQ1_0';
 export const MEDPSY_1_7B = 'medpsy-1.7b-q4_k_m-imat';
 export const MEDPSY_4B = 'medpsy-4b-q4_k_m-imat';
 export function isCapabilityProfile(value) {
@@ -26,6 +28,8 @@ const MODEL_NAME_TO_PROFILE = new Map([
     [QWEN_36_27B, 'xhigh'],
     [QWEN_36_35B_A3B, 'xhigh'],
     [QWEN_38_27B, 'xhigh'],
+    [BONSAI_2_27B_PQ2, 'high'],
+    [BONSAI_2_27B_PTQ1, 'high'],
     [MEDPSY_1_7B, 'low'],
     [MEDPSY_4B, 'mid']
 ]);
@@ -70,6 +74,8 @@ export const AGENT_MODEL_NAMES = [
     QWEN_36_27B,
     QWEN_36_35B_A3B,
     QWEN_38_27B,
+    BONSAI_2_27B_PQ2,
+    BONSAI_2_27B_PTQ1,
     MEDPSY_1_7B,
     MEDPSY_4B
 ];
@@ -87,7 +93,9 @@ const MULTIMODAL_LLMS = new Set([
     QWEN_35_9B,
     QWEN_36_27B,
     QWEN_36_35B_A3B,
-    QWEN_38_27B
+    QWEN_38_27B,
+    BONSAI_2_27B_PQ2,
+    BONSAI_2_27B_PTQ1
 ]);
 export function isMultimodalLlm(modelName) {
     return MULTIMODAL_LLMS.has(modelName);

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

@@ -6,8 +6,8 @@ import type { ModelAddon } from './model-source.ts';
 export interface SdkModelAsset extends ModelRegistryEntry {
     readonly src: string;
 }
-import { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName, type CapabilityProfile, type HostCapability, type ImageModelChoice, type ImageChoiceEntry } from './model-catalog-constants.ts';
-export { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName };
+import { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, BONSAI_2_27B_PQ2, BONSAI_2_27B_PTQ1, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName, type CapabilityProfile, type HostCapability, type ImageModelChoice, type ImageChoiceEntry } from './model-catalog-constants.ts';
+export { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, BONSAI_2_27B_PQ2, BONSAI_2_27B_PTQ1, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName };
 export type { CapabilityProfile, HostCapability, ImageModelChoice, ImageChoiceEntry };
 export interface LlmCatalogEntry {
     readonly name: string;
@@ -15,6 +15,7 @@ export interface LlmCatalogEntry {
     readonly capabilityProfile: CapabilityProfile;
     readonly projection?: SdkModelAsset;
     readonly textOnly?: true;
+    readonly toolDialect?: ToolDialect;
 }
 export declare const LLM_CATALOG: ReadonlyArray<LlmCatalogEntry>;
 export declare function defaultProjectionMap(): Record<string, string>;
@@ -52,6 +53,7 @@ export interface DiffusionDownloadMetadata {
 }
 export declare function diffusionDownloadName(model: string): string | null;
 export declare function diffusionDownloadMetadata(model: string, addon: ModelAddon | undefined): DiffusionDownloadMetadata | undefined;
+export declare function assetBytes(src: string): number | undefined;
 import { DEFAULT_MUSIC_MODEL_CHOICE, isMusicModelChoice, musicModelChoiceFrom, type MusicModelChoice } from './music-catalog.ts';
 export { DEFAULT_MUSIC_MODEL_CHOICE, isMusicModelChoice, musicModelChoiceFrom, type MusicModelChoice };
 export interface AudioGenCatalogEntry {
@@ -108,6 +110,7 @@ export declare function curatedListables(): CuratedListable[];
 export declare function curatedModelAsset(name: string, addon: ModelRegistryEntry['addon']): SdkModelAsset | undefined;
 export declare function modelAddonOf(model: string): ModelRegistryEntry['addon'];
 export declare function residentSrc(model: string, addon: ModelRegistryEntry['addon']): string;
+export declare function catalogModelName(model: string, addon: ModelRegistryEntry['addon']): string;
 export declare const CUSTOM_TASK_TYPES: readonly ['llm'];
 export type CustomTaskType = (typeof CUSTOM_TASK_TYPES)[number];
 export interface CustomModelEntry {
@@ -123,6 +126,7 @@ export declare function setCustomModels(entries: ReadonlyArray<CustomModelEntry>
 export declare function customModels(): ReadonlyArray<CustomModelEntry>;
 export declare function customContextLength(name: string): number | undefined;
 export declare function customModelSrc(name: string, addon: ModelRegistryEntry['addon']): string | undefined;
+export declare function toolDialectFor(name: string): ToolDialect | undefined;
 export declare function customToolDialect(name: string): ToolDialect | undefined;
 export declare function customProjectionMap(): Record<string, string>;
 export declare function companionRegistryPaths(): Map<string, string[]>;