@qvac/core 0.0.0 → 0.1.1

package/dist-lib/lib/model-clamp.js

@@ -0,0 +1,20 @@
+import { isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile } from '@qvac/harness/lib/models/model-catalog.ts';
+export function isMobilePlatform(platform) {
+    return platform === 'android' || platform === 'ios';
+}
+export function runnableModelName(requested, host, mobileClass) {
+    if (!host || !mobileClass)
+        return requested;
+    if (!isCapabilityProfile(host.capabilityProfile))
+        return requested;
+    const profile = host.capabilityProfile;
+    const required = modelNameToCapabilityProfile(requested);
+    if (!required)
+        return requested;
+    if (meetsMinCapabilityProfile(profile, required))
+        return requested;
+    const fallback = modelNameToCapabilityProfile(host.recommendedModelName);
+    if (!fallback || !meetsMinCapabilityProfile(required, fallback))
+        return requested;
+    return host.recommendedModelName;
+}

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

@@ -0,0 +1,13 @@
+export declare const MOBILE_CONTEXT_SIZE = 12288;
+export declare const MODEL_CONTEXT_TARGET: {
+    readonly desktop: "desktop";
+    readonly mobile: "mobile";
+};
+export type ModelContextTarget = (typeof MODEL_CONTEXT_TARGET)[keyof typeof MODEL_CONTEXT_TARGET];
+export declare function modelContextTargetForPlatform(platform: string | null | undefined): ModelContextTarget | null;
+export declare const DEFAULT_CONTEXT_SIZE = 8192;
+export declare const COMPACTION_MIN_CTX_SIZE = 4096;
+export declare function maxContextForModel(modelName: string): number;
+export declare function defaultContextForModel(modelName: string, target?: ModelContextTarget): number;
+export declare function formatTokenCount(n: number): string;
+export declare function contextOptionsForModel(modelName: string, target?: ModelContextTarget): ReadonlyArray<number>;

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

@@ -0,0 +1,71 @@
+import { QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, MEDPSY_1_7B, MEDPSY_4B } from "./llm-model-names.js";
+const QWEN_35_MAX_CONTEXT = 262_144;
+const QWEN_36_MAX_CONTEXT = 262_144;
+const QWEN_38_MAX_CONTEXT = 262_144;
+const MEDPSY_1_7B_MAX_CONTEXT = 32_768;
+const MEDPSY_4B_MAX_CONTEXT = 262_144;
+const DESKTOP_DEFAULT_CONTEXT_SIZE = 51_200;
+const MOBILE_SMALL_CONTEXT_SIZE = 12_288;
+export const MOBILE_CONTEXT_SIZE = MOBILE_SMALL_CONTEXT_SIZE;
+export const MODEL_CONTEXT_TARGET = {
+    desktop: 'desktop',
+    mobile: 'mobile'
+};
+export function modelContextTargetForPlatform(platform) {
+    if (!platform) {
+        return null;
+    }
+    if (platform === 'ios' || platform === 'android') {
+        return MODEL_CONTEXT_TARGET.mobile;
+    }
+    return MODEL_CONTEXT_TARGET.desktop;
+}
+const MODEL_CONTEXT_SPECS = [
+    { name: QWEN_35_2B, maxContextTokens: QWEN_35_MAX_CONTEXT, parameterBillions: 2 },
+    { name: QWEN_35_4B, maxContextTokens: QWEN_35_MAX_CONTEXT, parameterBillions: 4 },
+    { name: QWEN_35_9B, maxContextTokens: QWEN_35_MAX_CONTEXT, parameterBillions: 9 },
+    { name: QWEN_36_27B, maxContextTokens: QWEN_36_MAX_CONTEXT, parameterBillions: 27 },
+    { name: QWEN_36_35B_A3B, maxContextTokens: QWEN_36_MAX_CONTEXT, parameterBillions: 35 },
+    { name: QWEN_38_27B, maxContextTokens: QWEN_38_MAX_CONTEXT, parameterBillions: 27 },
+    { name: MEDPSY_1_7B, maxContextTokens: MEDPSY_1_7B_MAX_CONTEXT, parameterBillions: 1.7 },
+    { name: MEDPSY_4B, maxContextTokens: MEDPSY_4B_MAX_CONTEXT, parameterBillions: 4 }
+];
+const CONTEXT_BY_MODEL = new Map(MODEL_CONTEXT_SPECS.map((spec) => [spec.name, spec.maxContextTokens]));
+const SPEC_BY_MODEL = new Map(MODEL_CONTEXT_SPECS.map((spec) => [spec.name, spec]));
+const STANDARD_CONTEXT_OPTIONS = [
+    1_024, 2_048, 4_096, 8_192, 16_384, 32_768, 65_536, 131_072, 262_144
+];
+export const DEFAULT_CONTEXT_SIZE = 8_192;
+export const COMPACTION_MIN_CTX_SIZE = 4_096;
+export function maxContextForModel(modelName) {
+    return CONTEXT_BY_MODEL.get(modelName) ?? DEFAULT_CONTEXT_SIZE;
+}
+export function defaultContextForModel(modelName, target = MODEL_CONTEXT_TARGET.desktop) {
+    const spec = SPEC_BY_MODEL.get(modelName);
+    if (!spec) {
+        return DEFAULT_CONTEXT_SIZE;
+    }
+    if (target === MODEL_CONTEXT_TARGET.mobile && spec.parameterBillions <= 4) {
+        return Math.min(MOBILE_SMALL_CONTEXT_SIZE, spec.maxContextTokens);
+    }
+    return Math.min(DESKTOP_DEFAULT_CONTEXT_SIZE, spec.maxContextTokens);
+}
+export function formatTokenCount(n) {
+    if (n >= 1_000_000) {
+        return `${(n / 1_000_000).toLocaleString(undefined, { maximumFractionDigits: 1 })}M ctx`;
+    }
+    if (n >= 1_000) {
+        return `${(n / 1_000).toLocaleString(undefined, { maximumFractionDigits: 0 })}K ctx`;
+    }
+    return `${n.toLocaleString()} ctx`;
+}
+export function contextOptionsForModel(modelName, target = MODEL_CONTEXT_TARGET.desktop) {
+    const defaultContext = defaultContextForModel(modelName, target);
+    const ceiling = maxContextForModel(modelName);
+    const options = [
+        ...STANDARD_CONTEXT_OPTIONS.filter((size) => size <= ceiling),
+        defaultContext,
+        ceiling
+    ];
+    return [...new Set(options)].sort((a, b) => a - b);
+}

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

@@ -0,0 +1,29 @@
+import type { Logger } from './log.ts';
+export type ModelDownloadPhase = 'queued' | 'downloading' | 'paused' | 'error';
+export interface StatusRow {
+    phase: ModelDownloadPhase;
+    percentage: number;
+    error: string | null;
+    downloaded: number;
+    total: number;
+    bytesPerSecond: number;
+}
+type StatusPatch = Partial<Pick<StatusRow, 'percentage' | 'error' | 'downloaded' | 'total' | 'bytesPerSecond'>>;
+interface StatusEngine {
+    setModelDownloadStatus(request: StatusRow & {
+        name: string;
+    }): Promise<unknown>;
+    clearModelDownload(request: {
+        name: string;
+    }): Promise<unknown>;
+}
+export declare class ModelDownloadStatus {
+    private readonly _rows;
+    private readonly _engine;
+    private readonly _log;
+    constructor(engine: StatusEngine, logger?: Logger | null);
+    write(name: string, phase: ModelDownloadPhase, patch?: StatusPatch): Promise<boolean>;
+    clear(name: string): Promise<void>;
+    clearUnwanted(wanted: ReadonlySet<string>): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,56 @@
+export class ModelDownloadStatus {
+    _rows = new Map();
+    _engine;
+    _log;
+    constructor(engine, logger = null) {
+        this._engine = engine;
+        this._log = logger;
+    }
+    async write(name, phase, patch = {}) {
+        const previous = this._rows.get(name);
+        const next = {
+            phase,
+            percentage: patch.percentage ?? previous?.percentage ?? 0,
+            error: patch.error ?? null,
+            downloaded: patch.downloaded ?? previous?.downloaded ?? 0,
+            total: patch.total ?? previous?.total ?? 0,
+            bytesPerSecond: patch.bytesPerSecond ?? previous?.bytesPerSecond ?? 0
+        };
+        if (sameStatus(previous, next))
+            return true;
+        try {
+            await this._engine.setModelDownloadStatus({ name, ...next });
+            this._rows.set(name, next);
+            return true;
+        }
+        catch (err) {
+            this._log?.warn('model-download', 'local status write failed', err);
+            return false;
+        }
+    }
+    async clear(name) {
+        if (!this._rows.has(name))
+            return;
+        try {
+            await this._engine.clearModelDownload({ name });
+            this._rows.delete(name);
+        }
+        catch (err) {
+            this._log?.warn('model-download', 'local status clear failed', err);
+        }
+    }
+    async clearUnwanted(wanted) {
+        for (const name of [...this._rows.keys()]) {
+            if (!wanted.has(name))
+                await this.clear(name);
+        }
+    }
+}
+function sameStatus(previous, next) {
+    return (previous?.phase === next.phase &&
+        previous.percentage === next.percentage &&
+        previous.error === next.error &&
+        previous.downloaded === next.downloaded &&
+        previous.total === next.total &&
+        previous.bytesPerSecond === next.bytesPerSecond);
+}

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

@@ -0,0 +1,191 @@
+import { type AbortSignal } from 'bare-abort-controller';
+import { type AgentSkillModelInput } from '@qvac/harness/lib/models/model-catalog.ts';
+import type { AssistantAppConfig } from '../spec/hyperschema/types.d.ts';
+import { type ModelProgressFrame } from '@qvac/harness/model-progress';
+import { type HostCapability } from './model-clamp.ts';
+import { type StatusRow } from './model-download-status.ts';
+import type { Logger } from './log.ts';
+export interface DownloadArgs {
+    model: string;
+    addon?: string;
+    seed?: boolean;
+    signal?: AbortSignal;
+}
+export interface ImageDownloadObservation {
+    readonly model: string;
+    readonly phase: 'downloading' | 'complete';
+    readonly percentage: number;
+    readonly downloaded: number;
+    readonly total: number;
+}
+export type DownloadFrame = ModelProgressFrame;
+export type DownloadEventStream = AsyncIterable<ModelProgressFrame>;
+interface DownloadHarness {
+    list?(options?: {
+        cachedOnly?: boolean;
+    }): Promise<ReadonlyArray<{
+        name: string;
+        type: string;
+        isCached: boolean;
+        expectedSize?: number;
+    }>>;
+    infraModels?(profile: string): Promise<ReadonlyArray<{
+        name: string;
+        addon: string;
+    }>>;
+    capability?(): Promise<HostCapability>;
+    download?(args: DownloadArgs): DownloadEventStream;
+}
+interface DownloadEngine {
+    configWatchTyped(request: Record<string, never>): AsyncIterable<AssistantAppConfig>;
+    agentsWatch(request: Record<string, never>): AsyncIterable<unknown>;
+    listDevices(request: Record<string, never>): Promise<{
+        devices?: ReadonlyArray<{
+            id: Buffer;
+            capabilityProfile: string;
+        }> | null;
+    }>;
+    getAgent(request: {
+        id: string;
+    }): Promise<{
+        modelName?: string | null;
+        providerDeviceId?: Buffer | null;
+        enabledSkills?: ReadonlyArray<string> | null;
+        installedSkills?: ReadonlyArray<string> | null;
+        skillsScope?: 'all' | 'selected' | null;
+        imageModelChoice?: AgentSkillModelInput['imageModelChoice'];
+    } | null>;
+    listToolConfigs(request: {
+        agentId: string;
+    }): Promise<{
+        configs?: ReadonlyArray<{
+            toolName?: string | null;
+            settings?: unknown;
+        }> | null;
+    }>;
+    toolConfigsWatch(request: {
+        agentId: string;
+    }): AsyncIterable<unknown>;
+    modelDownloadsWatch(request: Record<string, never>): AsyncIterable<{
+        downloads?: ReadonlyArray<{
+            name: string;
+        }> | null;
+    }>;
+    setModelDownloadStatus(request: StatusRow & {
+        name: string;
+    }): Promise<unknown>;
+    clearModelDownload(request: {
+        name: string;
+    }): Promise<unknown>;
+    beginModelTransfer(request: {
+        name: string;
+        transferred?: boolean;
+    }): Promise<{
+        name: string;
+        transferId: string;
+    }>;
+    completeModelTransfer(request: {
+        name: string;
+        transferId: string;
+        downloaded?: boolean;
+    }): Promise<unknown>;
+}
+interface ReconcilerOptions {
+    engine: DownloadEngine;
+    harness: DownloadHarness;
+    deviceId: Buffer;
+    onCacheChanged: () => void;
+    retryMs?: number;
+    now?: () => number;
+    createScheduler?: (onFire: () => void) => RetryScheduler;
+    logger?: Logger | null;
+    mobileClass?: boolean;
+}
+interface RetryScheduler {
+    schedule(deadline: number): void;
+    clear(): void;
+}
+export declare class ModelDownloadReconciler {
+    private readonly _engine;
+    private readonly _harness;
+    private readonly _deviceId;
+    private readonly _onCacheChanged;
+    private readonly _log;
+    private readonly _status;
+    private readonly _retry;
+    private readonly _now;
+    private readonly _watchRetryMs;
+    private readonly _mobileClass;
+    private readonly _scheduler;
+    private readonly _attemptGenerations;
+    private readonly _transfers;
+    private readonly _completedTransfers;
+    private readonly _pendingCompletions;
+    private readonly _observedTransfers;
+    private readonly _observedProgress;
+    private readonly _observedSpeed;
+    private readonly _requestedModels;
+    private readonly _targetTotals;
+    private _config;
+    private _active;
+    private _localLlm;
+    private _localSkillModels;
+    private _musicChoice;
+    private _preemptLlm;
+    private _pausedLocalLlm;
+    private _profile;
+    private _capability;
+    private readonly _handled;
+    private readonly _demands;
+    private _dirty;
+    private _running;
+    private _paused;
+    private _runModels;
+    private _closed;
+    private _configStream;
+    private _agentsStream;
+    private _toolConfigsStream;
+    private _toolConfigsAgentId;
+    private readonly _timers;
+    constructor({ engine, harness, deviceId, onCacheChanged, retryMs, now, createScheduler, logger, mobileClass }: ReconcilerOptions);
+    start(): void;
+    private _reset;
+    suspend(): Promise<void>;
+    resume(): void;
+    yieldToRuns(models: ReadonlyArray<string>): void;
+    observeImageProgress(observation: ImageDownloadObservation): void;
+    private _transfer;
+    private _completeTransfer;
+    waitUntilCached(model: string, signal: AbortSignal): Promise<void>;
+    retry(name: string): Promise<void>;
+    close(): Promise<void>;
+    private _watchConfig;
+    private _syncToolConfigsWatch;
+    private _watchToolConfigs;
+    private _watchAgents;
+    private _restartWatch;
+    private _scheduleRestart;
+    private _kick;
+    private _drain;
+    private _step;
+    private _writeWaiting;
+    private _flushObservedProgress;
+    private _shouldPreempt;
+    private _waiting;
+    private _nextTarget;
+    private _scheduleNextRetry;
+    private _desired;
+    private _modelAvailability;
+    private _deviceProfile;
+    private _hostCapability;
+    private _refreshLocalAgentModels;
+    private _musicModelChoice;
+    private _begin;
+    private _removeDemandWaiter;
+    private _resolveDemand;
+    private _failDemand;
+    private _attemptGeneration;
+    private _stopActive;
+    private _download;
+}
+export {};