@qvac/sdk 0.5.0 → 0.6.0

package/dist/server/bare/registry/model-config-utils.js

@@ -0,0 +1,121 @@
+import { ModelType, } from "../../../schemas/index.js";
+import { llmConfigSchema, embedConfigSchema } from "../../../schemas/llamacpp-config.js";
+import { whisperConfigSchema } from "../../../schemas/whispercpp-config.js";
+import { ocrConfigSchema } from "../../../schemas/ocr.js";
+export const CANONICAL_TO_ALIAS = {
+    [ModelType.llamacppCompletion]: "llm",
+    [ModelType.llamacppEmbedding]: "embeddings",
+    [ModelType.whispercppTranscription]: "whisper",
+    [ModelType.nmtcppTranslation]: "nmt",
+    [ModelType.onnxTts]: "tts",
+    [ModelType.onnxOcr]: "ocr",
+};
+export const MODEL_CONFIG_SCHEMAS = {
+    [ModelType.llamacppCompletion]: llmConfigSchema,
+    [ModelType.llamacppEmbedding]: embedConfigSchema,
+    [ModelType.whispercppTranscription]: whisperConfigSchema,
+    [ModelType.onnxOcr]: ocrConfigSchema,
+};
+// Ordered general → specific (later patterns override earlier)
+export const BUILTIN_DEVICE_PATTERNS = [
+    {
+        name: "Android devices (SDK default)",
+        match: {
+            platform: "android",
+        },
+        defaults: {
+            [ModelType.llamacppEmbedding]: { flashAttention: "off" },
+        },
+    },
+    {
+        name: "Pixel devices (SDK default)",
+        match: {
+            platform: "android",
+            deviceBrand: "google",
+            deviceModelPrefix: "Pixel",
+        },
+        defaults: {
+            [ModelType.llamacppCompletion]: { device: "cpu" },
+            [ModelType.llamacppEmbedding]: { device: "cpu" },
+        },
+    },
+    {
+        name: "iPhone 17",
+        match: {
+            platform: "ios",
+            deviceModelPrefix: "iPhone 17",
+        },
+        defaults: {
+            [ModelType.llamacppCompletion]: { device: "cpu" },
+            [ModelType.llamacppEmbedding]: { device: "cpu" },
+        },
+    },
+];
+export function matchesPattern(ctx, match) {
+    if (match.platform !== undefined && ctx.platform !== match.platform) {
+        return false;
+    }
+    if (match.deviceBrand !== undefined &&
+        ctx.deviceBrand?.toLowerCase() !== match.deviceBrand.toLowerCase()) {
+        return false;
+    }
+    if (match.deviceModelPrefix !== undefined &&
+        !(ctx.deviceModel?.startsWith(match.deviceModelPrefix) ?? false)) {
+        return false;
+    }
+    if (match.deviceModelContains !== undefined &&
+        !(ctx.deviceModel?.includes(match.deviceModelContains) ?? false)) {
+        return false;
+    }
+    return true;
+}
+export function findAllMatchingPatterns(ctx, patterns) {
+    return patterns.filter((pattern) => matchesPattern(ctx, pattern.match));
+}
+export function getDefaultsFromPattern(modelType, pattern) {
+    let defaults = pattern.defaults[modelType];
+    if (!defaults) {
+        const aliasKey = CANONICAL_TO_ALIAS[modelType];
+        if (aliasKey && aliasKey in pattern.defaults) {
+            defaults = pattern.defaults[aliasKey];
+        }
+    }
+    return defaults;
+}
+export function resolveModelConfigWithContext(modelType, userInput, ctx, userPatterns, builtinPatterns = BUILTIN_DEVICE_PATTERNS, onLog) {
+    // Find ALL matching patterns (general → specific order preserved)
+    const matchingBuiltin = findAllMatchingPatterns(ctx, builtinPatterns);
+    const matchingUser = findAllMatchingPatterns(ctx, userPatterns);
+    // Merge in order: builtin patterns → user patterns → user input
+    // Later values override earlier (more specific wins)
+    const appliedPatterns = [];
+    let mergedDefaults = {};
+    for (const pattern of matchingBuiltin) {
+        const defaults = getDefaultsFromPattern(modelType, pattern);
+        if (defaults) {
+            appliedPatterns.push(pattern.name);
+            mergedDefaults = { ...mergedDefaults, ...defaults };
+        }
+    }
+    for (const pattern of matchingUser) {
+        const defaults = getDefaultsFromPattern(modelType, pattern);
+        if (defaults) {
+            appliedPatterns.push(pattern.name);
+            mergedDefaults = { ...mergedDefaults, ...defaults };
+        }
+    }
+    const merged = {
+        ...mergedDefaults,
+        ...userInput,
+    };
+    const schema = MODEL_CONFIG_SCHEMAS[modelType];
+    const finalConfig = schema ? schema.parse(merged) : merged;
+    if (onLog) {
+        onLog({
+            appliedPatterns,
+            mergedDefaults,
+            finalConfig: finalConfig,
+        });
+    }
+    return finalConfig;
+}

package/dist/server/bare/registry/model-registry.d.ts

@@ -1,36 +1,13 @@
-import type EventEmitter from "events";
 import type FilesystemDL from "@qvac/dl-filesystem";
-import type { ModelType } from "../../../schemas/index";
+import type { CanonicalModelType } from "../../../schemas/index";
+import type BaseInference from "@qvac/infer-base";
 interface AddonInterface {
     cancel(jobId?: string): Promise<void>;
 }
-export interface AnyModel {
-    load(...args: unknown[]): Promise<void>;
-    run(input: unknown): Promise<EventEmitter & {
-        onUpdate(callback: (data: string) => void): {
-            await: () => Promise<void>;
-        };
-        onUpdate(callback: (data: {
-            outputArray: Int16Array;
-        }) => void): {
-            await: () => Promise<void>;
-        };
-        onError(callback: (error: Error) => void): void;
-        onUpdate(callback: (data: Array<{
-            text: string;
-        }>) => void): {
-            await: () => Promise<void>;
-        };
-        cancel(): Promise<void>;
-        iterate(): AsyncIterableIterator<string | Array<{
-            text: string;
-        }>>;
-        await(): Promise<void>;
-    }>;
+export type AnyModel = Omit<BaseInference, "addon"> & {
     reload?(config: unknown): Promise<void>;
-    unload?(): Promise<void>;
     addon?: AddonInterface;
-}
+};
 interface DelegateOptions {
     topic: string;
     providerPublicKey: string;
@@ -41,7 +18,7 @@ interface LocalOptions {
     path: string;
     loadedAt: Date;
     config: unknown;
-    modelType: ModelType;
+    modelType: CanonicalModelType;
     name?: string | undefined;
     loader: FilesystemDL;
 }
@@ -55,7 +32,7 @@ export declare function registerModel(id: string, options: {
     model: AnyModel;
     path: string;
     config: unknown;
-    modelType: ModelType;
+    modelType: CanonicalModelType;
     loader: FilesystemDL;
     name?: string | undefined;
 } | {

package/dist/server/bare/registry/runtime-context-registry.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeContext } from "../../../schemas/index";
+export declare function setRuntimeContext(ctx: RuntimeContext): void;
+export declare function getRuntimeContext(): RuntimeContext;
+export declare function isMobile(): boolean;
+export declare function isAndroid(): boolean;
+export declare function isIOS(): boolean;
+//# sourceMappingURL=runtime-context-registry.d.ts.map

package/dist/server/bare/registry/runtime-context-registry.js

@@ -0,0 +1,26 @@
+// ============================================
+// Runtime context state
+// ============================================
+let context = {};
+let isSet = false;
+export function setRuntimeContext(ctx) {
+    if (isSet)
+        return;
+    context = ctx;
+    isSet = true;
+}
+export function getRuntimeContext() {
+    return context;
+}
+// ============================================
+// Convenience helpers
+// ============================================
+export function isMobile() {
+    return context.runtime === "react-native";
+}
+export function isAndroid() {
+    return context.platform === "android";
+}
+export function isIOS() {
+    return context.platform === "ios";
+}

package/dist/server/bare/utils/loader-adapter.d.ts

@@ -0,0 +1,7 @@
+import type FilesystemDL from "@qvac/dl-filesystem";
+/**
+ * Adapts FilesystemDL to addon Loader interface by adding download stub.
+ * download() is never called when using filesystem loader.
+ */
+export declare function asLoader<T>(loader: FilesystemDL): T;
+//# sourceMappingURL=loader-adapter.d.ts.map

package/dist/server/bare/utils/loader-adapter.js

@@ -0,0 +1,9 @@
+/**
+ * Adapts FilesystemDL to addon Loader interface by adding download stub.
+ * download() is never called when using filesystem loader.
+ */
+export function asLoader(loader) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+    loader.download = () => Promise.reject(new Error("download not supported"));
+    return loader;
+}

package/dist/server/error-handlers.js

@@ -1,4 +1,6 @@
 import { createErrorResponse, responseSchema } from "../schemas/index.js";
+import { getServerLogger } from "../logging/index.js";
+const logger = getServerLogger();
 export function sendErrorResponse(req, error) {
     try {
         const errorResponse = createErrorResponse(error);
@@ -6,7 +8,7 @@ export function sendErrorResponse(req, error) {
         req.reply(responseData, "utf-8");
     }
     catch (responseError) {
-        console.error("Failed to create error response:", responseError);
+        logger.error("Failed to create error response:", responseError);
         const fallbackError = createErrorResponse(new Error("Internal server error"));
         req.reply(JSON.stringify(fallbackError), "utf-8");
     }
@@ -19,7 +21,7 @@ export function sendStreamErrorResponse(stream, error) {
         stream.end();
     }
     catch (responseError) {
-        console.error("Failed to create stream error response:", responseError);
+        logger.error("Failed to create stream error response:", responseError);
         const fallbackError = createErrorResponse(new Error("Internal server error"));
         stream.write(JSON.stringify(fallbackError) + "\n", "utf-8");
         stream.end();

package/dist/server/rpc/handle-request.js

@@ -1,11 +1,12 @@
 import { requestSchema, responseSchema, } from "../../schemas/index.js";
 import { handleCompletionStream } from "./handlers/completion-stream.js";
 import { handleDownloadAsset } from "./handlers/download-asset.js";
-import { handleLoadModel } from "./handlers/load-model.js";
+import { handleLoadModel } from "./handlers/load-model/index.js";
 import { handleLoadModelDelegated } from "./handlers/load-model-delegated.js";
 import { handleCompletionStreamDelegated } from "./handlers/completion-stream-delegated.js";
 import { getModelEntry } from "../bare/registry/model-registry.js";
 import { setSDKConfig } from "../bare/registry/config-registry.js";
+import { setRuntimeContext } from "../bare/registry/runtime-context-registry.js";
 import { handleUnloadModel } from "./handlers/unload-model.js";
 import { handleTranscribeStream } from "./handlers/transcribe-stream.js";
 import { handleEmbed } from "./handlers/embed.js";
@@ -18,8 +19,11 @@ import { handleRag } from "./handlers/rag.js";
 import { handleDeleteCache } from "./handlers/delete-cache.js";
 import { handleTextToSpeech } from "./handlers/text-to-speech.js";
 import { handleGetModelInfo } from "./handlers/get-model-info.js";
+import { handleOCRStream } from "./handlers/ocr-stream.js";
 import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
 import { NoDataReceivedError, UnknownRequestTypeError, } from "../../utils/errors-client.js";
+import { normalizeModelType } from "../../schemas/index.js";
+import { resolveModelConfig } from "../bare/registry/model-config-registry.js";
 export async function handleRequest(req) {
     try {
         const rawData = req.data?.toString();
@@ -33,8 +37,13 @@ export async function handleRequest(req) {
             "type" in jsonData &&
             jsonData.type === "__init_config") {
             try {
-                const configData = jsonData;
-                setSDKConfig(configData.config);
+                const initData = jsonData;
+                if (initData.config) {
+                    setSDKConfig(initData.config);
+                }
+                if (initData.runtimeContext) {
+                    setRuntimeContext(initData.runtimeContext);
+                }
                 req.reply(JSON.stringify({ success: true }), "utf-8");
             }
             catch (error) {
@@ -45,7 +54,8 @@ export async function handleRequest(req) {
             }
             return;
         }
-        const request = requestSchema.parse(jsonData);
+        const processedData = applyDeviceDefaultsToRequest(jsonData);
+        const request = requestSchema.parse(processedData);
         switch (request.type) {
             case "downloadAsset": {
                 if (request.withProgress) {
@@ -235,12 +245,35 @@ export async function handleRequest(req) {
                 break;
             }
             case "rag": {
-                try {
-                    const response = await handleRag(request);
-                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                // Only ingest, saveEmbeddings, and reindex support progress
+                const supportsProgress = request.operation === "ingest" ||
+                    request.operation === "saveEmbeddings" ||
+                    request.operation === "reindex";
+                const withProgress = supportsProgress && request.withProgress;
+                if (withProgress) {
+                    const stream = req.createResponseStream();
+                    try {
+                        const response = await handleRag(request, (update) => {
+                            const data = JSON.stringify(responseSchema.parse(update));
+                            stream.write(data + "\n", "utf-8");
+                        });
+                        // Send final response
+                        const data = JSON.stringify(responseSchema.parse(response));
+                        stream.write(data + "\n", "utf-8");
+                        stream.end();
+                    }
+                    catch (error) {
+                        sendStreamErrorResponse(stream, error);
+                    }
                 }
-                catch (error) {
-                    sendErrorResponse(req, error);
+                else {
+                    try {
+                        const response = await handleRag(request);
+                        req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                    }
+                    catch (error) {
+                        sendErrorResponse(req, error);
+                    }
                 }
                 break;
             }
@@ -279,6 +312,21 @@ export async function handleRequest(req) {
                 }
                 break;
             }
+            case "ocrStream": {
+                const stream = req.createResponseStream();
+                try {
+                    for await (const response of handleOCRStream(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
+                }
+                catch (error) {
+                    sendStreamErrorResponse(stream, error);
+                }
+                break;
+            }
             default: {
                 throw new UnknownRequestTypeError();
             }
@@ -288,3 +336,37 @@ export async function handleRequest(req) {
         sendErrorResponse(req, error);
     }
 }
+/**
+ * Apply device-specific config defaults to loadModel requests before schema parsing.
+ * This ensures device defaults are applied before schema defaults.
+ *
+ * Priority: User config > Device defaults > Schema defaults
+ */
+function applyDeviceDefaultsToRequest(data) {
+    if (!data || typeof data !== "object")
+        return data;
+    const obj = data;
+    const requestType = obj["type"];
+    // Only process loadModel requests (not reload config which uses modelId)
+    if (requestType !== "loadModel" ||
+        !obj["modelType"] ||
+        !("modelSrc" in obj)) {
+        return data;
+    }
+    // Normalize model type to canonical form
+    let canonicalType;
+    try {
+        canonicalType = normalizeModelType(obj["modelType"]);
+    }
+    catch {
+        // Invalid model type, let schema validation handle it
+        return data;
+    }
+    // Apply device defaults and full schema defaults to modelConfig
+    const rawConfig = obj["modelConfig"] ?? {};
+    const configWithDefaults = resolveModelConfig(canonicalType, rawConfig);
+    return {
+        ...obj,
+        modelConfig: configWithDefaults,
+    };
+}

package/dist/server/rpc/handlers/cancelHandler.js

@@ -1,5 +1,6 @@
 import { cancel } from "../../bare/addons/index.js";
 import { createCancelFunction } from "./load-model/download-manager.js";
+import { cancelRagOperation, DEFAULT_WORKSPACE, } from "../../bare/rag-hyperdb/index.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
 export async function cancelHandler(request) {
@@ -8,10 +9,18 @@ export async function cancelHandler(request) {
             case "inference":
                 await cancel({ modelId: request.modelId });
                 break;
-            case "downloadAsset":
+            case "downloadAsset": {
                 const cancelDownload = createCancelFunction(request.downloadKey, request.clearCache);
                 cancelDownload();
                 break;
+            }
+            case "rag": {
+                const cancelled = cancelRagOperation(request.workspace);
+                if (!cancelled) {
+                    logger.warn(`No active RAG operation to cancel for workspace: ${request.workspace ?? DEFAULT_WORKSPACE}`);
+                }
+                break;
+            }
         }
         return {
             type: "cancel",

package/dist/server/rpc/handlers/completion-stream.js

@@ -1,4 +1,4 @@
-import { completion } from "../../bare/addons/llamacpp/index.js";
+import { completion } from "../../bare/addons/llamacpp-completion/index.js";
 export async function* handleCompletionStream(request) {
     const filteredHistory = request.history.map(({ role, content, attachments }) => ({
         role,

package/dist/server/rpc/handlers/delete-cache.js

@@ -1,4 +1,4 @@
-import { deleteCache as deleteCacheUtil } from "../../bare/addons/llamacpp/kv-cache-utils.js";
+import { deleteCache as deleteCacheUtil } from "../../bare/addons/llamacpp-completion/index.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
 export async function handleDeleteCache(request) {

package/dist/server/rpc/handlers/embed.js

@@ -1,4 +1,4 @@
-import { embed } from "../../bare/addons/llamacpp/index.js";
+import { embed } from "../../bare/addons/llamacpp-embedding/index.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
 export async function handleEmbed(request) {

package/dist/server/rpc/handlers/get-model-info.d.ts

@@ -1,3 +1,3 @@
 import type { GetModelInfoRequest, GetModelInfoResponse } from "../../../schemas/index";
-export declare const handleGetModelInfo: (request: GetModelInfoRequest) => Promise<GetModelInfoResponse>;
+export declare function handleGetModelInfo(request: GetModelInfoRequest): Promise<GetModelInfoResponse>;
 //# sourceMappingURL=get-model-info.d.ts.map

package/dist/server/rpc/handlers/get-model-info.js

@@ -6,7 +6,8 @@ import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { getShardPath } from "../../utils/cache.js";
 import { ModelNotFoundError } from "../../../utils/errors-server.js";
-export const handleGetModelInfo = async (request) => {
+import { normalizeModelType } from "../../../schemas/model-types.js";
+export async function handleGetModelInfo(request) {
     const { name } = request;
     const catalogEntry = models.find((m) => m.name === name);
     if (!catalogEntry) {
@@ -34,6 +35,10 @@ export const handleGetModelInfo = async (request) => {
         }
     }
     const isLoaded = loadedInstances.length > 0;
+    // Normalize addon from alias to canonical (vad passes through as-is)
+    const normalizedAddon = catalogEntry.addon === "vad"
+        ? "vad"
+        : normalizeModelType(catalogEntry.addon);
     const modelInfo = {
         name: catalogEntry.name,
         modelId: catalogEntry.modelId,
@@ -41,7 +46,7 @@ export const handleGetModelInfo = async (request) => {
         hyperbeeKey: catalogEntry.hyperbeeKey,
         expectedSize: catalogEntry.expectedSize,
         sha256Checksum: catalogEntry.sha256Checksum,
-        addon: catalogEntry.addon,
+        addon: normalizedAddon,
         isCached,
         isLoaded,
         cacheFiles,
@@ -53,7 +58,7 @@ export const handleGetModelInfo = async (request) => {
         type: "getModelInfo",
         modelInfo,
     };
-};
+}
 async function handleShardedModel(hyperdriveKey, shardMetadata) {
     const cacheFiles = [];
     let allShardsCached = true;
@@ -66,13 +71,19 @@ async function handleShardedModel(hyperdriveKey, shardMetadata) {
         let shardCachedAt;
         try {
             const stats = await fsPromises.stat(shardPath);
-            shardIsCached = stats.isFile();
-            if (shardIsCached) {
+            const fileExists = stats.isFile();
+            if (fileExists) {
                 shardActualSize = stats.size;
                 shardCachedAt = stats.mtime;
-                totalActualSize += stats.size;
-                if (!latestCachedAt || stats.mtime > latestCachedAt) {
-                    latestCachedAt = stats.mtime;
+                shardIsCached = stats.size === shard.expectedSize;
+                if (shardIsCached) {
+                    totalActualSize += stats.size;
+                    if (!latestCachedAt || stats.mtime > latestCachedAt) {
+                        latestCachedAt = stats.mtime;
+                    }
+                }
+                else {
+                    allShardsCached = false;
                 }
             }
             else {
@@ -114,10 +125,11 @@ async function handleSingleFileModel(hyperdriveKey, modelId, expectedSize, sha25
     let fileCachedAt;
     try {
         const stats = await fsPromises.stat(filePath);
-        fileIsCached = stats.isFile();
-        if (fileIsCached) {
+        const fileExists = stats.isFile();
+        if (fileExists) {
             fileActualSize = stats.size;
             fileCachedAt = stats.mtime;
+            fileIsCached = stats.size === expectedSize;
         }
     }
     catch {

package/dist/server/rpc/handlers/index.d.ts

@@ -12,6 +12,8 @@ import { handleRag } from "./rag";
 import { cancelHandler } from "./cancelHandler";
 import { handleDeleteCache } from "./delete-cache";
 import { handleTextToSpeech } from "./text-to-speech";
+import { handleGetModelInfo } from "./get-model-info";
+import { handleOCRStream } from "./ocr-stream";
 export declare const handlers: {
     completionStream: typeof handleCompletionStream;
     downloadAsset: typeof handleDownloadAsset;
@@ -27,6 +29,7 @@ export declare const handlers: {
     rag: typeof handleRag;
     cancel: typeof cancelHandler;
     textToSpeech: typeof handleTextToSpeech;
-    getModelInfo: (request: import("../../../schemas").GetModelInfoRequest) => Promise<import("../../../schemas").GetModelInfoResponse>;
+    getModelInfo: typeof handleGetModelInfo;
+    ocrStream: typeof handleOCRStream;
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/server/rpc/handlers/index.js

@@ -13,6 +13,7 @@ import { cancelHandler } from "./cancelHandler.js";
 import { handleDeleteCache } from "./delete-cache.js";
 import { handleTextToSpeech } from "./text-to-speech.js";
 import { handleGetModelInfo } from "./get-model-info.js";
+import { handleOCRStream } from "./ocr-stream.js";
 export const handlers = {
     completionStream: handleCompletionStream,
     downloadAsset: handleDownloadAsset,
@@ -29,4 +30,5 @@ export const handlers = {
     cancel: cancelHandler,
     textToSpeech: handleTextToSpeech,
     getModelInfo: handleGetModelInfo,
+    ocrStream: handleOCRStream,
 };

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

@@ -1,13 +1,13 @@
 import { type DownloadEntry } from "../../../../schemas/index";
-export declare const getActiveDownload: (key: string) => DownloadEntry | undefined;
-export declare const registerDownload: (key: string, entry: DownloadEntry) => void;
-export declare const unregisterDownload: (key: string) => void;
-export declare const createHyperdriveDownloadKey: (hyperdriveKey: string, modelFileName: string) => string;
-export declare const createHttpDownloadKey: (url: string) => string;
-export declare const setClearCacheFlag: (downloadKey: string, clearCache: boolean) => void;
-export declare const shouldClearCache: (downloadKey: string) => boolean;
-export declare const clearClearCacheFlag: (downloadKey: string) => void;
-export declare const createCancelFunction: (downloadKey: string, clearCache?: boolean) => () => void;
-export declare const cancelAllDownloads: () => void;
-export declare const cleanupDownloads: () => Promise<void>;
+export declare function getActiveDownload(key: string): DownloadEntry | undefined;
+export declare function registerDownload(key: string, entry: DownloadEntry): void;
+export declare function unregisterDownload(key: string): void;
+export declare function createHyperdriveDownloadKey(hyperdriveKey: string, modelFileName: string): string;
+export declare function createHttpDownloadKey(url: string): string;
+export declare function setClearCacheFlag(downloadKey: string, clearCache: boolean): void;
+export declare function shouldClearCache(downloadKey: string): boolean;
+export declare function clearClearCacheFlag(downloadKey: string): void;
+export declare function createCancelFunction(downloadKey: string, clearCache?: boolean): () => void;
+export declare function cancelAllDownloads(): void;
+export declare function cleanupDownloads(): Promise<void>;
 //# sourceMappingURL=download-manager.d.ts.map