@qvac/sdk 0.17.1 → 0.18.1

package/dist/server/rpc/handlers/load-model/resolve-session.js

@@ -12,14 +12,14 @@ export function createResolveSession(options) {
         },
         ...(requestBinding !== undefined && { requestBinding })
     };
-    async function resolvePrimaryModelPath(modelSrc) {
+    async function resolvePrimaryModelPath(modelSrc, fallbackSrc) {
         if (profilingEnabled) {
-            const result = await resolveModelPathWithStats(modelSrc, progressCallback, seed, signal, downloadHooks);
+            const result = await resolveModelPathWithStats(modelSrc, progressCallback, seed, signal, downloadHooks, fallbackSrc);
             primaryResult = result;
             resolveResults.push(result);
             return result.path;
         }
-        return resolveModelPath(modelSrc, progressCallback, seed, signal, downloadHooks);
+        return resolveModelPath(modelSrc, progressCallback, seed, signal, downloadHooks, fallbackSrc);
     }
     async function resolveForPlugin(src) {
         if (profilingEnabled) {

package/dist/server/rpc/handlers/load-model/resolve.d.ts

@@ -1,6 +1,16 @@
 import { type ModelProgressUpdate } from '../../../../schemas/index.js';
 import type { ResolveResult, DownloadHooks } from './types.js';
 import type { AbortSignal } from 'bare-abort-controller';
-export declare function resolveModelPath(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean, signal?: AbortSignal, hooks?: DownloadHooks): Promise<string>;
-export declare function resolveModelPathWithStats(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean, signal?: AbortSignal, hooks?: DownloadHooks): Promise<ResolveResult>;
+type ResolveMode = 'base' | 'stats';
+export declare function resolveFallbackModel(fallbackSrc: string, expectedChecksum: string | undefined, progressCallback: ((progress: ModelProgressUpdate) => void) | undefined, mode: ResolveMode, signal: AbortSignal | undefined, hooks: DownloadHooks | undefined): Promise<ResolveResult>;
+export declare function resolveRegistryModel(params: {
+    hasFallback: boolean;
+    isKnownModel: boolean;
+    downloadPrimary: () => Promise<ResolveResult>;
+    resolveFallback: () => Promise<ResolveResult>;
+    buildUnreachableError: (cause: unknown) => Error;
+}): Promise<ResolveResult>;
+export declare function resolveModelPath(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean, signal?: AbortSignal, hooks?: DownloadHooks, fallbackSrc?: string): Promise<string>;
+export declare function resolveModelPathWithStats(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean, signal?: AbortSignal, hooks?: DownloadHooks, fallbackSrc?: string): Promise<ResolveResult>;
+export {};
 //# sourceMappingURL=resolve.d.ts.map

package/dist/server/rpc/handlers/load-model/resolve.js

@@ -1,6 +1,6 @@
 import { models, getModelByPath } from '../../../../models/registry/models.js';
 import { hyperdriveUrlSchema, registryUrlSchema, SUPPORTED_ARCHIVE_EXTENSIONS } from '../../../../schemas/index.js';
-import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, extractAndValidateShardedArchive } from '../../../../server/utils/index.js';
+import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, extractAndValidateShardedArchive, measureChecksum } from '../../../../server/utils/index.js';
 import { promises as fsPromises } from 'bare-fs';
 import path from 'bare-path';
 import { downloadModelFromHttp } from './http.js';
@@ -8,7 +8,7 @@ import { downloadModelFromHyperdrive } from './hyperdrive.js';
 import { downloadModelFromRegistry } from './registry.js';
 import { getExplicitRegistryMetadata } from './registry-metadata.js';
 import { downloadModelFromHttpWithStats, downloadModelFromHyperdriveWithStats, downloadModelFromRegistryWithStats } from './download-stats.js';
-import { InferenceCancelledError, ModelLoadFailedError, ModelNotFoundError, SeedingNotSupportedError } from '../../../../utils/errors-server.js';
+import { ChecksumValidationFailedError, DownloadCancelledError, InferenceCancelledError, ModelFileNotFoundError, ModelLoadFailedError, ModelNotFoundError, SeedingNotSupportedError } from '../../../../utils/errors-server.js';
 import { validateAndJoinPath } from '../../../../server/utils/path-security.js';
 import { getServerLogger } from '../../../../logging/index.js';
 import { modelInputToSrcSchema } from '../../../../schemas/index.js';
@@ -75,11 +75,66 @@ function buildResult(pathOrResult, sourceType) {
     }
     return { path: pathOrResult, sourceType };
 }
-async function resolveModelPathCore(modelSrc, progressCallback, seed, mode, signal, hooks) {
+// A fallback is a non-P2P source: only HTTP URLs and file paths are valid.
+// registry:// and pear:// are rejected.
+export async function resolveFallbackModel(fallbackSrc, expectedChecksum, progressCallback, mode, signal, hooks) {
+    if (fallbackSrc.startsWith('registry://') || fallbackSrc.startsWith('pear://')) {
+        throw new ModelLoadFailedError('fallbackSrc must be an HTTP URL or a local file path.');
+    }
+    // seed applies only to hyperdrive sources, which a fallback can never be.
+    const result = await resolveModelPathCore(fallbackSrc, progressCallback, false, mode, signal, hooks);
+    // Report a missing fallback file as a not-found error before checksumming.
+    try {
+        await fsPromises.access(result.path);
+    }
+    catch {
+        throw new ModelFileNotFoundError(result.path);
+    }
+    if (expectedChecksum && expectedChecksum.length === 64) {
+        const actualChecksum = await measureChecksum(result.path, hooks);
+        if (actualChecksum !== expectedChecksum) {
+            // http downloads are cached under the models dir; drop a corrupt one.
+            if (result.sourceType === 'http') {
+                await fsPromises.unlink(result.path).catch(() => { });
+            }
+            throw new ChecksumValidationFailedError(fallbackSrc);
+        }
+    }
+    return result;
+}
+// Registry download with optional fallback. A user-initiated cancel always
+// propagates. On any other primary failure: a fallback is taken when present;
+// otherwise a known model surfaces a neutral error and an unknown one rethrows.
+export async function resolveRegistryModel(params) {
+    try {
+        return await params.downloadPrimary();
+    }
+    catch (error) {
+        if (error instanceof InferenceCancelledError || error instanceof DownloadCancelledError) {
+            throw error;
+        }
+        if (params.hasFallback) {
+            return params.resolveFallback();
+        }
+        const isCorrectnessError = error instanceof ChecksumValidationFailedError ||
+            error instanceof ModelNotFoundError ||
+            error instanceof ModelFileNotFoundError;
+        if (params.isKnownModel && !isCorrectnessError) {
+            throw params.buildUnreachableError(error);
+        }
+        throw error;
+    }
+}
+async function resolveModelPathCore(modelSrc, progressCallback, seed, mode, signal, hooks, fallbackSrc) {
     if (signal?.aborted) {
         throw new InferenceCancelledError(hooks?.requestBinding?.requestId ?? 'unknown');
     }
     const srcString = modelInputToSrcSchema.parse(modelSrc);
+    // A fallback is validated against the catalog checksum, which exists only for
+    // built-in registry models. Other sources have no checksum to validate against.
+    if (fallbackSrc !== undefined && !srcString.startsWith('registry://')) {
+        throw new ModelLoadFailedError('fallbackSrc is only supported when modelSrc is a built-in registry model.');
+    }
     // Empty modelSrc is reserved for plugins that ship bundled weights
     // (e.g. `@qvac/classification-ggml`). The handler skips this resolver
     // for them when `skipPrimaryModelPathValidation` is set, but if it
@@ -105,11 +160,34 @@ async function resolveModelPathCore(modelSrc, progressCallback, seed, mode, sign
         const modelMetadata = getModelByPath(registryPath);
         const explicitMetadata = getExplicitRegistryMetadata(modelSrc);
         const expectedChecksum = modelMetadata?.sha256Checksum ?? explicitMetadata?.sha256Checksum;
-        const result = mode === 'stats'
-            ? await downloadModelFromRegistryWithStats(registryPath, registrySource, progressCallback, expectedChecksum, hooks, explicitMetadata)
-            : await downloadModelFromRegistry(registryPath, registrySource, progressCallback, expectedChecksum, hooks, explicitMetadata);
-        logger.info(`Loaded Model to ${isDownloadResult(result) ? result.path : result}`);
-        return buildResult(result, 'registry');
+        // An uncatalogued registry path carries no checksum to validate a fallback against.
+        if (fallbackSrc !== undefined && !modelMetadata) {
+            throw new ModelLoadFailedError('fallbackSrc is only supported when modelSrc is a built-in registry model.');
+        }
+        // A single-file fallback cannot satisfy a sharded or companion-set model.
+        if (fallbackSrc !== undefined &&
+            (modelMetadata?.shardMetadata || modelMetadata?.companionSet)) {
+            throw new ModelLoadFailedError('fallbackSrc is not supported for sharded or multi-file models.');
+        }
+        return resolveRegistryModel({
+            hasFallback: fallbackSrc !== undefined,
+            isKnownModel: modelMetadata !== undefined,
+            downloadPrimary: async () => {
+                const result = mode === 'stats'
+                    ? await downloadModelFromRegistryWithStats(registryPath, registrySource, progressCallback, expectedChecksum, hooks, explicitMetadata)
+                    : await downloadModelFromRegistry(registryPath, registrySource, progressCallback, expectedChecksum, hooks, explicitMetadata);
+                logger.info(`Loaded Model to ${isDownloadResult(result) ? result.path : result}`);
+                return buildResult(result, 'registry');
+            },
+            resolveFallback: () => {
+                logger.info(`Registry download failed for ${registryPath}; trying fallbackSrc: ${fallbackSrc}`);
+                return resolveFallbackModel(fallbackSrc, expectedChecksum, progressCallback, mode, signal, hooks);
+            },
+            buildUnreachableError: (cause) => new ModelLoadFailedError(`Could not download "${modelMetadata?.modelId}" from the registry on this network ` +
+                `(${cause instanceof Error ? cause.message : String(cause)}). ` +
+                'If the registry is not reliably reachable here, pass a fallbackSrc ' +
+                '(an HTTP URL or local file path) to load this model from an alternate source.', cause)
+        });
     }
     // Validate seeding is only used with hyperdrive models
     if (seed && !hyperdriveKey) {
@@ -150,10 +228,10 @@ async function resolveModelPathCore(modelSrc, progressCallback, seed, mode, sign
     }
     return { path: resolvedPath, sourceType: 'filesystem' };
 }
-export async function resolveModelPath(modelSrc, progressCallback, seed, signal, hooks) {
-    const result = await resolveModelPathCore(modelSrc, progressCallback, seed, 'base', signal, hooks);
+export async function resolveModelPath(modelSrc, progressCallback, seed, signal, hooks, fallbackSrc) {
+    const result = await resolveModelPathCore(modelSrc, progressCallback, seed, 'base', signal, hooks, fallbackSrc);
     return result.path;
 }
-export async function resolveModelPathWithStats(modelSrc, progressCallback, seed, signal, hooks) {
-    return resolveModelPathCore(modelSrc, progressCallback, seed, 'stats', signal, hooks);
+export async function resolveModelPathWithStats(modelSrc, progressCallback, seed, signal, hooks, fallbackSrc) {
+    return resolveModelPathCore(modelSrc, progressCallback, seed, 'stats', signal, hooks, fallbackSrc);
 }

package/dist/server/utils/audio/decoder.d.ts

@@ -1,5 +1,41 @@
+import { type DecoderOutput } from '@qvac/decoder-audio';
 import { Readable } from 'bare-stream';
 import { type AudioFormat } from '../../../schemas/index.js';
 export declare function needsDecoding(filePath: string): boolean;
-export declare function decodeAudioToStream(inputPath: string, audioFormat?: AudioFormat): Promise<Readable>;
+/**
+ * Longest silence the decoder may go without emitting a PCM chunk before the
+ * decode is abandoned. Measured between outputs, not against the whole file, so
+ * long inputs decode fine as long as FFmpeg keeps producing data.
+ */
+export declare const DECODER_INACTIVITY_TIMEOUT_MS = 10000;
+export interface DecodeAudioOptions {
+    /** Output sample rate; the decoder's default is 16 kHz (what every transcription engine expects). */
+    sampleRate?: number;
+    /** Inactivity timeout between decoded chunks (default `DECODER_INACTIVITY_TIMEOUT_MS`). */
+    inactivityTimeoutMs?: number;
+}
+/** The subset of the decoder's `QvacResponse` that the stream bridge consumes. */
+export interface DecoderResponseLike {
+    onUpdate(callback: (output: DecoderOutput) => void): DecoderResponseLike;
+    onFinish(callback: () => void): DecoderResponseLike;
+    onError(callback: (error: Error) => void): DecoderResponseLike;
+    await(): Promise<unknown>;
+}
+export interface DecoderStreamOptions {
+    /** Used in error messages only. */
+    inputPath: string;
+    inactivityTimeoutMs?: number;
+    /** Runs once, on whichever terminal path (finish, error, timeout) settles the stream. */
+    onSettled?: () => void;
+}
+/**
+ * Decode an audio file into a raw mono PCM stream.
+ */
+export declare function decodeAudioToStream(inputPath: string, audioFormat?: AudioFormat, options?: DecodeAudioOptions): Promise<Readable>;
+/**
+ * Bridge a decoder response into a `Readable` of PCM chunks. The stream fails
+ * if the decoder emits nothing for `inactivityTimeoutMs`; the timer is re-armed
+ * on every chunk, so it bounds inactivity, not the total decode time.
+ */
+export declare function decoderResponseToStream(response: DecoderResponseLike, options: DecoderStreamOptions): Readable;
 //# sourceMappingURL=decoder.d.ts.map

package/dist/server/utils/audio/decoder.js

@@ -10,65 +10,30 @@ export function needsDecoding(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return FORMATS_NEEDING_DECODE.includes(ext);
 }
-const DECODER_TIMEOUT_MS = 10000;
-export async function decodeAudioToStream(inputPath, audioFormat = 's16le') {
+/**
+ * Longest silence the decoder may go without emitting a PCM chunk before the
+ * decode is abandoned. Measured between outputs, not against the whole file, so
+ * long inputs decode fine as long as FFmpeg keeps producing data.
+ */
+export const DECODER_INACTIVITY_TIMEOUT_MS = 10000;
+/**
+ * Decode an audio file into a raw mono PCM stream.
+ */
+export async function decodeAudioToStream(inputPath, audioFormat = 's16le', options = {}) {
+    const { sampleRate, inactivityTimeoutMs = DECODER_INACTIVITY_TIMEOUT_MS } = options;
     const decoder = new FFmpegDecoder({
-        config: { audioFormat },
+        config: { audioFormat, ...(sampleRate !== undefined && { sampleRate }) },
         logger
     });
     try {
         await decoder.load();
         const audioStream = fs.createReadStream(inputPath);
         const response = decoder.run(audioStream);
-        const outputStream = new Readable({
-            read() { }
+        return decoderResponseToStream(response, {
+            inputPath,
+            inactivityTimeoutMs,
+            onSettled: () => setImmediate(() => void decoder.unload())
         });
-        let hasReceivedData = false;
-        let hasEnded = false;
-        // Fallback timeout in case the decoder hangs without emitting any events
-        const timeoutId = setTimeout(() => {
-            if (!hasEnded) {
-                hasEnded = true;
-                const timeoutError = new Error(`Audio decoding timed out after ${DECODER_TIMEOUT_MS}ms for file: ${inputPath}`);
-                outputStream.destroy(timeoutError);
-            }
-        }, DECODER_TIMEOUT_MS);
-        response
-            .onUpdate((output) => {
-            hasReceivedData = true;
-            const bytes = new Uint8Array(output.outputArray);
-            outputStream.push(Buffer.from(bytes));
-        })
-            .onFinish(() => {
-            if (!hasEnded) {
-                hasEnded = true;
-                clearTimeout(timeoutId);
-                setImmediate(() => void decoder.unload());
-                if (!hasReceivedData) {
-                    outputStream.destroy(new Error(`No audio data decoded from file: ${inputPath}`));
-                }
-                else {
-                    outputStream.push(null);
-                }
-            }
-        })
-            .onError((error) => {
-            if (!hasEnded) {
-                hasEnded = true;
-                clearTimeout(timeoutId);
-                setImmediate(() => void decoder.unload());
-                outputStream.destroy(error);
-            }
-        });
-        response.await().catch((error) => {
-            if (!hasEnded) {
-                hasEnded = true;
-                clearTimeout(timeoutId);
-                setImmediate(() => void decoder.unload());
-                outputStream.destroy(error instanceof Error ? error : new Error(String(error)));
-            }
-        });
-        return outputStream;
     }
     catch (error) {
         await decoder.unload();
@@ -76,3 +41,68 @@ export async function decodeAudioToStream(inputPath, audioFormat = 's16le') {
         throw error;
     }
 }
+/**
+ * Bridge a decoder response into a `Readable` of PCM chunks. The stream fails
+ * if the decoder emits nothing for `inactivityTimeoutMs`; the timer is re-armed
+ * on every chunk, so it bounds inactivity, not the total decode time.
+ */
+export function decoderResponseToStream(response, options) {
+    const { inputPath, inactivityTimeoutMs = DECODER_INACTIVITY_TIMEOUT_MS, onSettled } = options;
+    const outputStream = new Readable({
+        read() { }
+    });
+    let hasReceivedData = false;
+    let hasEnded = false;
+    let timeoutId;
+    const settle = () => {
+        if (hasEnded)
+            return false;
+        hasEnded = true;
+        if (timeoutId !== undefined)
+            clearTimeout(timeoutId);
+        onSettled?.();
+        return true;
+    };
+    const armTimeout = () => {
+        if (timeoutId !== undefined)
+            clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => {
+            if (!settle())
+                return;
+            outputStream.destroy(new Error(`Audio decoding produced no output for ${inactivityTimeoutMs}ms for file: ${inputPath}`));
+        }, inactivityTimeoutMs);
+    };
+    armTimeout();
+    outputStream.on('close', () => {
+        settle();
+    });
+    response
+        .onUpdate((output) => {
+        hasReceivedData = true;
+        if (!hasEnded)
+            armTimeout();
+        const bytes = new Uint8Array(output.outputArray);
+        outputStream.push(Buffer.from(bytes));
+    })
+        .onFinish(() => {
+        if (!settle())
+            return;
+        if (!hasReceivedData) {
+            outputStream.destroy(new Error(`No audio data decoded from file: ${inputPath}`));
+        }
+        else {
+            outputStream.push(null);
+        }
+    })
+        .onError((error) => {
+        if (!settle())
+            return;
+        outputStream.destroy(error);
+    });
+    response.await().catch((error) => {
+        if (!settle())
+            return;
+        outputStream.destroy(error instanceof Error ? error : new Error(String(error)));
+    });
+    return outputStream;
+}

package/dist/server/utils/config-transform.d.ts

@@ -1,3 +1,6 @@
 import { type ModelTypeInput } from '../../schemas/index.js';
+export declare function getModelParallel(config: {
+    parallel?: number | undefined;
+}): number;
 export declare function transformConfigForReload(modelType: ModelTypeInput, config: unknown): unknown;
 //# sourceMappingURL=config-transform.d.ts.map

package/dist/server/utils/config-transform.js

@@ -1,5 +1,11 @@
 import { normalizeModelType, ModelType } from '../../schemas/index.js';
 import { buildParakeetReloadConfig, buildWhisperReloadConfig } from '../../server/bare/plugins/asr-ggml/config.js';
+// The model's concurrent sequence slots. Missing / 0 / NaN all mean single-slot;
+// floor a fractional value so it can't over-admit.
+export function getModelParallel(config) {
+    const n = Math.floor(Number(config.parallel));
+    return Number.isFinite(n) && n >= 1 ? n : 1;
+}
 export function transformConfigForReload(modelType, config) {
     const canonicalType = normalizeModelType(modelType);
     switch (canonicalType) {

package/dist/server/utils/index.d.ts

@@ -4,7 +4,6 @@ export * from './cache/auto-history.js';
 export * from './cache/paths.js';
 export * from './checksum.js';
 export * from './config-transform.js';
-export * from './expand-gguf-shards.js';
 export * from './formatting.js';
 export * from './gguf-tensor-extractor.js';
 export * from './path-security.js';

package/dist/server/utils/index.js

@@ -4,7 +4,6 @@ export * from './cache/auto-history.js';
 export * from './cache/paths.js';
 export * from './checksum.js';
 export * from './config-transform.js';
-export * from './expand-gguf-shards.js';
 export * from './formatting.js';
 export * from './gguf-tensor-extractor.js';
 export * from './path-security.js';

package/dist/server/utils/shard-utils.d.ts

@@ -3,6 +3,7 @@ import type { ShardPatternInfo, ShardUrl } from '../../schemas/index.js';
  * Detect if model filename follows shard pattern (00001-of-0000x)
  */
 export declare function detectShardedModel(filename: string): ShardPatternInfo;
+export declare function getFirstShardPath(modelPath: string): string;
 /**
  * Generate list of shard filenames for a sharded model
  * Accepts any shard in the group

package/dist/server/utils/shard-utils.js

@@ -20,6 +20,20 @@ export function detectShardedModel(filename) {
     }
     return { isSharded: false };
 }
+export function getFirstShardPath(modelPath) {
+    const lastSeparator = Math.max(modelPath.lastIndexOf('/'), modelPath.lastIndexOf('\\'));
+    const directory = lastSeparator >= 0 ? modelPath.slice(0, lastSeparator + 1) : '';
+    const filename = lastSeparator >= 0 ? modelPath.slice(lastSeparator + 1) : modelPath;
+    const shardInfo = detectShardedModel(filename);
+    if (!shardInfo.isSharded ||
+        !shardInfo.baseFilename ||
+        !shardInfo.totalShards ||
+        !shardInfo.extension) {
+        return modelPath;
+    }
+    const totalShards = shardInfo.totalShards.toString().padStart(5, '0');
+    return `${directory}${shardInfo.baseFilename}-00001-of-${totalShards}${shardInfo.extension}`;
+}
 /**
  * Generate list of shard filenames for a sharded model
  * Accepts any shard in the group

package/dist/server/utils/tool-integration.d.ts

@@ -7,18 +7,11 @@ interface HistoryMessage {
     }[] | undefined;
 }
 /**
- * Static tools mode: prepend tools right after the system message (or at the
- * very start when no system message is present). The tool block stays in the
- * kv-cache for the whole chat session.
+ * Prepend tools right after the system message (or at the very start when no
+ * system message is present). The tool block stays in the kv-cache for the
+ * whole chat session.
  */
 export declare function prependToolsToHistory(history: HistoryMessage[], tools: Tool[]): Array<HistoryMessage | Tool>;
-/**
- * Dynamic tools mode: append tools after the last history message. The
- * addon's compact-tools mode anchors the block after the last user message
- * and trims it from the kv-cache once the tool-call chain resolves, so a
- * subsequent turn can ship a different tool set without poisoning the cache.
- */
-export declare function appendToolsToHistory(history: HistoryMessage[], tools: Tool[]): Array<HistoryMessage | Tool>;
 export declare function detectToolDialect(modelId: string): ToolDialect;
 export {};
 //# sourceMappingURL=tool-integration.d.ts.map

package/dist/server/utils/tool-integration.js

@@ -1,9 +1,9 @@
 import { detectToolDialectFromName } from '../../server/utils/tools/index.js';
 import { getModelInfo } from '../../server/bare/registry/model-registry.js';
 /**
- * Static tools mode: prepend tools right after the system message (or at the
- * very start when no system message is present). The tool block stays in the
- * kv-cache for the whole chat session.
+ * Prepend tools right after the system message (or at the very start when no
+ * system message is present). The tool block stays in the kv-cache for the
+ * whole chat session.
  */
 export function prependToolsToHistory(history, tools) {
     const systemMsgIndex = history.findIndex((msg) => msg.role === 'system');
@@ -12,15 +12,6 @@ export function prependToolsToHistory(history, tools) {
     }
     return [...tools, ...history];
 }
-/**
- * Dynamic tools mode: append tools after the last history message. The
- * addon's compact-tools mode anchors the block after the last user message
- * and trims it from the kv-cache once the tool-call chain resolves, so a
- * subsequent turn can ship a different tool set without poisoning the cache.
- */
-export function appendToolsToHistory(history, tools) {
-    return [...history, ...tools];
-}
 export function detectToolDialect(modelId) {
     const info = getModelInfo(modelId);
     if (!info)

package/dist/utils/errors-server.d.ts

@@ -209,6 +209,9 @@ export declare class ImageFileNotFoundError extends QvacErrorBase {
 export declare class InvalidImageInputError extends QvacErrorBase {
     constructor(cause?: unknown);
 }
+export declare class InvalidAudioInputError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
 export declare class RAGSaveFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }

package/dist/utils/errors-server.js

@@ -318,6 +318,11 @@ export class InvalidImageInputError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.INVALID_IMAGE_INPUT, undefined, cause));
     }
 }
+export class InvalidAudioInputError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.INVALID_AUDIO_INPUT, details ? [details] : undefined, cause));
+    }
+}
 // ============== RAG Operation Errors ==============
 export class RAGSaveFailedError extends QvacErrorBase {
     constructor(details, cause) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/sdk",
-  "version": "0.17.1",
+  "version": "0.18.1",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -124,6 +124,11 @@
       "types": "./dist/schemas/plugin.d.ts",
       "import": "./dist/schemas/plugin.js"
     },
+    "./schemas": {
+      "types": "./dist/schemas/public.d.ts",
+      "import": "./dist/schemas/public.js",
+      "require": "./dist/schemas/public.js"
+    },
     "./expo-plugin": "./dist/expo/plugins/index.js",
     "./electron-forge": {
       "require": "./electron-forge/index.cjs",
@@ -192,6 +197,7 @@
     "postcompile:aliases": "tsc-alias -p tsconfig.alias.json",
     "build": "rm -rf dist && npm run lint && tsc --project tsconfig.json && npm run postcompile:aliases",
     "build:pack": "bun run build && bun pm pack --destination dist/",
+    "sdk-source:workspace": "bun run ./scripts/link-workspace-inference.ts",
     "watch": "nodemon --watch server --ext ts --exec 'bun run build'",
     "bare:ensureprebuilds:llamacpp": "cp -r node_modules/@qvac/llm-llamacpp/prebuilds/android-arm64 node_modules/@qvac/llm-llamacpp/prebuilds/android-ia32 && cp -r node_modules/@qvac/llm-llamacpp/prebuilds/android-arm64 node_modules/@qvac/llm-llamacpp/prebuilds/android-arm && cp -r node_modules/@qvac/llm-llamacpp/prebuilds/android-arm64 node_modules/@qvac/llm-llamacpp/prebuilds/android-x64",
     "bare:ensureprebuilds:asr": "cp -r node_modules/@qvac/asr-ggml/prebuilds/android-arm64 node_modules/@qvac/asr-ggml/prebuilds/android-ia32 && cp -r node_modules/@qvac/asr-ggml/prebuilds/android-arm64 node_modules/@qvac/asr-ggml/prebuilds/android-arm && cp -r node_modules/@qvac/asr-ggml/prebuilds/android-arm64 node_modules/@qvac/asr-ggml/prebuilds/android-x64",
@@ -202,29 +208,26 @@
     "contract:export": "tsx ./scripts/export-contract.ts",
     "contract:check": "tsx ./scripts/export-contract.ts --check",
     "check:resource-collectors": "tsx ./scripts/check-resource-collectors-packaging.ts",
-    "check-models": "tsx ./models/update-models/index.ts --check",
-    "check-models:hook": "tsx ./models/update-models/index.ts --check --non-blocking",
-    "update-models": "tsx ./models/update-models/index.ts && bun run contract:export",
     "changelog:generate": "node ../../scripts/sdk/generate-changelog-sdk-pod.cjs --package=sdk && prettier --write changelog"
   },
   "dependencies": {
-    "@qvac/audiogen-ggml": "^0.1.0",
-    "@qvac/asr-ggml": "^0.1.0",
-    "@qvac/bci-whispercpp": "^0.6.0",
-    "@qvac/classification-ggml": "^0.15.1",
+    "@qvac/audiogen-ggml": "^0.2.1",
+    "@qvac/asr-ggml": "^0.3.0",
+    "@qvac/bci-whispercpp": "^0.7.1",
+    "@qvac/classification-ggml": "^0.20.0",
     "@qvac/decoder-audio": "^0.5.0",
     "@qvac/diffusion-cpp": "^0.17.0",
-    "@qvac/embed-llamacpp": "^0.30.1",
+    "@qvac/embed-llamacpp": "^0.34.0",
     "@qvac/error": "^0.1.1",
     "@qvac/langdetect-text": "^0.1.2",
-    "@qvac/llm-llamacpp": "^0.39.3",
+    "@qvac/llm-llamacpp": "^0.45.0",
     "@qvac/logging": "^0.1.0",
-    "@qvac/ocr-ggml": "^0.13.1",
+    "@qvac/ocr-ggml": "^0.18.0",
     "@qvac/rag": "^0.6.4",
     "@qvac/registry-client": "^0.6.1",
-    "@qvac/translation-nmtcpp": "^8.3.0",
-    "@qvac/tts-ggml": "^0.6.0",
-    "@qvac/vla-ggml": "^0.16.2",
+    "@qvac/translation-nmtcpp": "^0.10.0",
+    "@qvac/tts-ggml": "^0.7.4",
+    "@qvac/vla-ggml": "^0.21.1",
     "bare-abort-controller": "^1.0.0",
     "bare-cpu-info": "0.1.1",
     "bare-crypto": "^1.15.0",

package/dist/examples/llamacpp-dynamic-tools.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=llamacpp-dynamic-tools.d.ts.map