@qvac/sdk 0.8.0 → 1.0.0

package/dist/server/rpc/delegate-transport.js

@@ -1,215 +0,0 @@
-/**
- * Server-side RPC transport for delegated requests.
- *
- * This module provides `send` and `stream` functions for server-side
- * delegation to remote peers (via HyperSwarm RPC).
- */
-import { requestSchema, responseSchema, PROFILING_KEY, DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, } from "../../schemas/index.js";
-import { nowMs, extractProfilingMeta, recordFailure, generateId, } from "../../profiling/index.js";
-import { withTimeout, withTimeoutStream } from "../../utils/withTimeout.js";
-import { getServerLogger } from "../../logging/index.js";
-import { DelegateProviderError } from "../../utils/errors-server.js";
-import { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, buildDelegationStreamBreakdown, flushServerConnectionEvent, consumeBreakdownConnectionTime, } from "./profiling/delegation-profiler.js";
-const logger = getServerLogger();
-let commandCounter = 0;
-function getNextCommandId() {
-    commandCounter = (commandCounter + 1) % Number.MAX_SAFE_INTEGER;
-    return commandCounter;
-}
-function checkAndThrowError(response) {
-    if (response.type === "error") {
-        throw new DelegateProviderError(response.message || "Unknown provider error", response.code);
-    }
-}
-export async function send(request, rpc, options) {
-    const { profilingMeta } = options ?? {};
-    const shouldProfile = shouldProfileDelegation(request.type, profilingMeta);
-    if (!shouldProfile) {
-        return sendBase(request, rpc, options, profilingMeta);
-    }
-    return sendProfiled(request, rpc, options, profilingMeta);
-}
-async function sendBase(request, rpc, options, profilingMeta) {
-    const parsedRequest = requestSchema.parse(request);
-    const req = rpc.request(getNextCommandId());
-    logger.debug("[delegate-transport] Sending:", { type: request.type });
-    // Propagate per-call disable signal to delegated provider
-    const finalRequest = profilingMeta?.enabled === false
-        ? { ...parsedRequest, [PROFILING_KEY]: { enabled: false } }
-        : parsedRequest;
-    const payload = JSON.stringify(finalRequest);
-    req.send(payload, "utf-8");
-    const response = await withTimeout(req.reply("utf-8"), options?.timeout);
-    const resPayload = responseSchema.parse(JSON.parse(response?.toString() || "{}"));
-    logger.debug("[delegate-transport] Response:", { type: resPayload.type });
-    checkAndThrowError(resPayload);
-    return resPayload;
-}
-async function sendProfiled(request, rpc, options, profilingMeta) {
-    const profileId = profilingMeta?.id ?? generateId();
-    const includeServerBreakdown = profilingMeta?.includeServer ?? false;
-    const timings = createDelegationTimings(profileId, request.type);
-    try {
-        if (options?.peerKey) {
-            flushServerConnectionEvent(options.peerKey);
-        }
-        const connectionMs = options?.peerKey
-            ? consumeBreakdownConnectionTime(options.peerKey)
-            : undefined;
-        const parsedRequest = requestSchema.parse(request);
-        const req = rpc.request(getNextCommandId());
-        logger.debug("[delegate-transport] Sending (profiled):", {
-            type: request.type,
-        });
-        const stringifyStart = nowMs();
-        const profilingEnvelope = { id: profileId };
-        if (includeServerBreakdown) {
-            profilingEnvelope["includeServer"] = true;
-        }
-        const requestWithProfiling = {
-            ...parsedRequest,
-            [PROFILING_KEY]: profilingEnvelope,
-        };
-        const payload = JSON.stringify(requestWithProfiling);
-        timings.requestStringifyMs = nowMs() - stringifyStart;
-        timings.sendStart = nowMs();
-        req.send(payload, "utf-8");
-        const response = await withTimeout(req.reply("utf-8"), options?.timeout);
-        timings.firstResponseAt = nowMs();
-        const parseStart = nowMs();
-        const rawPayload = JSON.parse(response?.toString() || "{}");
-        timings.responseJsonParseMs = nowMs() - parseStart;
-        const resPayload = responseSchema.parse(rawPayload);
-        logger.debug("[delegate-transport] Response (profiled):", {
-            type: resPayload.type,
-        });
-        checkAndThrowError(resPayload);
-        const serverMeta = extractProfilingMeta(rawPayload);
-        const delegationBreakdown = recordDelegationEvents(timings, serverMeta, connectionMs);
-        resPayload[DELEGATION_BREAKDOWN_KEY] = delegationBreakdown;
-        if (serverMeta?.operation) {
-            resPayload[OPERATION_EVENT_KEY] = serverMeta.operation;
-        }
-        return resPayload;
-    }
-    catch (error) {
-        const base = {
-            ts: nowMs(),
-            op: timings.requestType,
-            kind: "delegation",
-            profileId: timings.profileId,
-        };
-        recordFailure(base, timings.requestStart, error);
-        throw error;
-    }
-}
-export async function* stream(request, rpc, options = {}) {
-    const { profilingMeta } = options;
-    const shouldProfile = shouldProfileDelegation(request.type, profilingMeta);
-    if (!shouldProfile) {
-        yield* streamBase(request, rpc, options, profilingMeta);
-        return;
-    }
-    yield* streamProfiled(request, rpc, options, profilingMeta);
-}
-async function* streamBase(request, rpc, options = {}, profilingMeta) {
-    const parsedRequest = requestSchema.parse(request);
-    const req = rpc.request(getNextCommandId());
-    logger.debug("[delegate-transport] Streaming:", { type: request.type });
-    // Propagate per-call disable signal to delegated provider
-    const finalRequest = profilingMeta?.enabled === false
-        ? { ...parsedRequest, [PROFILING_KEY]: { enabled: false } }
-        : parsedRequest;
-    req.send(JSON.stringify(finalRequest), "utf-8");
-    const responseStream = req.createResponseStream({ encoding: "utf-8" });
-    let buffer = "";
-    async function* processStream() {
-        for await (const chunk of responseStream) {
-            yield chunk;
-        }
-    }
-    const streamWithTimeout = withTimeoutStream(processStream(), options?.timeout);
-    for await (const chunk of streamWithTimeout) {
-        buffer += chunk.toString();
-        // Process complete lines (newline-delimited JSON)
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || ""; // Keep incomplete line in buffer
-        for (const line of lines) {
-            if (line.trim()) {
-                const response = responseSchema.parse(JSON.parse(line));
-                checkAndThrowError(response);
-                yield response;
-            }
-        }
-    }
-}
-async function* streamProfiled(request, rpc, options = {}, profilingMeta) {
-    const profileId = profilingMeta?.id ?? generateId();
-    const timings = createDelegationStreamTimings(profileId, request.type);
-    try {
-        if (options.peerKey) {
-            flushServerConnectionEvent(options.peerKey);
-        }
-        const parsedRequest = requestSchema.parse(request);
-        const req = rpc.request(getNextCommandId());
-        logger.debug("[delegate-transport] Streaming (profiled):", {
-            type: request.type,
-        });
-        const stringifyStart = nowMs();
-        const requestWithProfiling = {
-            ...parsedRequest,
-            [PROFILING_KEY]: { id: profileId },
-        };
-        const payload = JSON.stringify(requestWithProfiling);
-        timings.requestStringifyMs = nowMs() - stringifyStart;
-        timings.sendStart = nowMs();
-        req.send(payload, "utf-8");
-        const responseStream = req.createResponseStream({ encoding: "utf-8" });
-        let buffer = "";
-        async function* processStream() {
-            for await (const chunk of responseStream) {
-                yield chunk;
-            }
-        }
-        const streamWithTimeout = withTimeoutStream(processStream(), options?.timeout);
-        let lastServerMeta;
-        for await (const chunk of streamWithTimeout) {
-            buffer += chunk.toString();
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
-            for (const line of lines) {
-                if (line.trim()) {
-                    const rawPayload = JSON.parse(line);
-                    const response = responseSchema.parse(rawPayload);
-                    checkAndThrowError(response);
-                    timings.chunkCount++;
-                    if (timings.firstChunkAt === undefined) {
-                        timings.firstChunkAt = nowMs();
-                    }
-                    timings.lastChunkAt = nowMs();
-                    const serverMeta = extractProfilingMeta(rawPayload);
-                    if (serverMeta?.operation) {
-                        response[OPERATION_EVENT_KEY] = serverMeta.operation;
-                    }
-                    if (serverMeta) {
-                        lastServerMeta = serverMeta;
-                    }
-                    response[DELEGATION_BREAKDOWN_KEY] =
-                        buildDelegationStreamBreakdown(timings);
-                    yield response;
-                }
-            }
-        }
-        recordDelegationStreamEvents(timings, lastServerMeta);
-    }
-    catch (error) {
-        const base = {
-            ts: nowMs(),
-            op: timings.requestType,
-            kind: "delegation",
-            profileId: timings.profileId,
-        };
-        recordFailure(base, timings.requestStart, error);
-        throw error;
-    }
-}

package/dist/server/rpc/handler-registry.d.ts

@@ -1,3 +0,0 @@
-import type { HandlerEntry } from "./handler-utils";
-export declare const registry: Record<string, HandlerEntry>;
-//# sourceMappingURL=handler-registry.d.ts.map

package/dist/server/rpc/handler-registry.js

@@ -1,90 +0,0 @@
-import {} from "../../schemas/index.js";
-import { handleCompletionStream } from "./handlers/completion-stream.js";
-import { handleDownloadAsset } from "./handlers/download-asset.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 { handleUnloadModel } from "./handlers/unload-model.js";
-import { handleUnloadModelDelegated } from "./handlers/unload-model-delegated.js";
-import { handleTranscribeStream } from "./handlers/transcribe-stream.js";
-import { handleEmbed } from "./handlers/embed.js";
-import { handleTranslate } from "./handlers/translate.js";
-import { handleLoggingStream } from "./handlers/logging-stream.js";
-import { cancelHandler } from "./handlers/cancelHandler.js";
-import { provideHandler } from "./handlers/provideHandler.js";
-import { stopProvideHandler } from "./handlers/stopProvideHandler.js";
-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 { handlePing } from "./handlers/ping.js";
-import { handlePluginInvoke, handlePluginInvokeStream, } from "./handlers/plugin-invoke.js";
-import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./handlers/registry.js";
-function ragSupportsProgress(request) {
-    if (request.type !== "rag")
-        return false;
-    return ["ingest", "saveEmbeddings", "reindex"].includes(request.operation);
-}
-function isModelDelegated(request) {
-    if (!("modelId" in request))
-        return false;
-    const entry = getModelEntry(request.modelId);
-    return entry?.isDelegated ?? false;
-}
-export const registry = {
-    // Simple Reply handlers
-    ping: { type: "reply", handler: handlePing },
-    unloadModel: {
-        type: "reply",
-        handler: handleUnloadModel,
-        delegatedHandler: handleUnloadModelDelegated,
-        isDelegated: isModelDelegated,
-    },
-    embed: { type: "reply", handler: handleEmbed },
-    cancel: { type: "reply", handler: cancelHandler },
-    provide: { type: "reply", handler: provideHandler },
-    stopProvide: { type: "reply", handler: stopProvideHandler },
-    deleteCache: { type: "reply", handler: handleDeleteCache },
-    getModelInfo: { type: "reply", handler: handleGetModelInfo },
-    pluginInvoke: { type: "reply", handler: handlePluginInvoke },
-    modelRegistryList: { type: "reply", handler: handleModelRegistryList },
-    modelRegistrySearch: { type: "reply", handler: handleModelRegistrySearch },
-    modelRegistryGetModel: {
-        type: "reply",
-        handler: handleModelRegistryGetModel,
-    },
-    // Simple Stream handlers
-    transcribeStream: { type: "stream", handler: handleTranscribeStream },
-    loggingStream: { type: "stream", handler: handleLoggingStream },
-    translate: { type: "stream", handler: handleTranslate },
-    textToSpeech: { type: "stream", handler: handleTextToSpeech },
-    ocrStream: { type: "stream", handler: handleOCRStream },
-    pluginInvokeStream: { type: "stream", handler: handlePluginInvokeStream },
-    // Handlers with delegation support
-    loadModel: {
-        type: "reply",
-        handler: handleLoadModel,
-        delegatedHandler: handleLoadModelDelegated,
-        isDelegated: (r) => r.type === "loadModel" && !!r.delegate,
-        supportsProgress: true,
-    },
-    completionStream: {
-        type: "stream",
-        handler: handleCompletionStream,
-        delegatedHandler: handleCompletionStreamDelegated,
-        isDelegated: isModelDelegated,
-    },
-    // Handlers with progress support
-    downloadAsset: {
-        type: "reply",
-        handler: handleDownloadAsset,
-        supportsProgress: true,
-    },
-    rag: {
-        type: "reply",
-        handler: handleRag,
-        supportsProgress: ragSupportsProgress,
-    },
-};

package/dist/server/rpc/handler-utils.d.ts

@@ -1,23 +0,0 @@
-import { type QvacConfig, type Request, type Response, type RuntimeContext } from "../../schemas/index";
-import type RPC from "bare-rpc";
-import { type ServerProfiler } from "./profiling/index";
-type ReplyHandler = (request: any, ...args: any[]) => Promise<Response> | Response;
-type StreamHandler = (request: any, ...args: any[]) => AsyncGenerator<Response>;
-type ProgressHandler = (request: any, ...args: any[]) => Promise<Response>;
-export type HandlerEntry = {
-    type: "reply" | "stream";
-    handler: ReplyHandler | StreamHandler | ProgressHandler;
-    delegatedHandler?: ReplyHandler | StreamHandler | ProgressHandler;
-    isDelegated?: (request: Request) => boolean;
-    supportsProgress?: boolean | ((request: Request) => boolean);
-};
-export declare function executeHandler(req: RPC.IncomingRequest, request: Request, entry: HandlerEntry, profiler: ServerProfiler): Promise<void>;
-type InitConfigMessage = {
-    type: "__init_config";
-    config: QvacConfig;
-    runtimeContext?: RuntimeContext;
-};
-export declare function isInitConfigMessage(data: unknown): data is InitConfigMessage;
-export declare function handleInitConfig(req: RPC.IncomingRequest, data: InitConfigMessage): void;
-export {};
-//# sourceMappingURL=handler-utils.d.ts.map

package/dist/server/rpc/handler-utils.js

@@ -1,128 +0,0 @@
-import { PROFILING_KEY, } from "../../schemas/index.js";
-import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
-import { setSDKConfig } from "../bare/registry/config-registry.js";
-import { setRuntimeContext } from "../bare/registry/runtime-context-registry.js";
-import {} from "./profiling/index.js";
-function getProfilingMetaFromRequest(request) {
-    if (PROFILING_KEY in request) {
-        return request[PROFILING_KEY];
-    }
-    return undefined;
-}
-async function executeReplyHandler(req, request, handler, profiler, isDelegated) {
-    profiler.startHandler();
-    try {
-        let response;
-        if (isDelegated) {
-            const profilingMeta = getProfilingMetaFromRequest(request);
-            response = await handler(request, profilingMeta ? { profilingMeta } : undefined);
-        }
-        else {
-            response = await handler(request);
-        }
-        profiler.endHandler();
-        req.reply(profiler.serialize(response, true), "utf-8");
-    }
-    catch (error) {
-        profiler.endHandler();
-        sendErrorResponse(req, error, profiler);
-    }
-}
-async function executeStreamHandler(req, request, handler, profiler, isDelegated) {
-    const stream = req.createResponseStream();
-    profiler.startHandler();
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let generator;
-        if (isDelegated) {
-            const profilingMeta = getProfilingMetaFromRequest(request);
-            generator = handler(request, profilingMeta ? { profilingMeta } : undefined);
-        }
-        else {
-            generator = handler(request);
-        }
-        for await (const response of generator) {
-            stream.write(profiler.serialize(response, false) + "\n", "utf-8");
-        }
-        profiler.endHandler();
-        const trailer = profiler.serialize();
-        if (trailer) {
-            stream.write(trailer + "\n", "utf-8");
-        }
-        stream.end();
-    }
-    catch (error) {
-        profiler.endHandler();
-        sendStreamErrorResponse(stream, error, profiler);
-    }
-}
-async function executeProgressHandler(req, request, handler, profiler, isDelegated) {
-    const stream = req.createResponseStream();
-    profiler.startHandler();
-    const progressCallback = (update) => {
-        stream.write(profiler.serialize(update, false) + "\n", "utf-8");
-    };
-    try {
-        let response;
-        if (isDelegated) {
-            const profilingMeta = getProfilingMetaFromRequest(request);
-            const options = { progressCallback };
-            if (profilingMeta) {
-                options.profilingMeta = profilingMeta;
-            }
-            response = await handler(request, options);
-        }
-        else {
-            response = await handler(request, progressCallback);
-        }
-        profiler.endHandler();
-        stream.write(profiler.serialize(response, true) + "\n", "utf-8");
-        stream.end();
-    }
-    catch (error) {
-        profiler.endHandler();
-        sendStreamErrorResponse(stream, error, profiler);
-    }
-}
-// Unified handler executor with delegation and progress support
-export async function executeHandler(req, request, entry, profiler) {
-    const isDelegated = !!(entry.delegatedHandler && entry.isDelegated?.(request));
-    const handler = isDelegated ? entry.delegatedHandler : entry.handler;
-    const wantsProgress = "withProgress" in request &&
-        request.withProgress &&
-        (typeof entry.supportsProgress === "function"
-            ? entry.supportsProgress(request)
-            : entry.supportsProgress);
-    if (entry.type === "stream") {
-        await executeStreamHandler(req, request, handler, profiler, isDelegated);
-    }
-    else if (wantsProgress) {
-        await executeProgressHandler(req, request, handler, profiler, isDelegated);
-    }
-    else {
-        await executeReplyHandler(req, request, handler, profiler, isDelegated);
-    }
-}
-export function isInitConfigMessage(data) {
-    return (typeof data === "object" &&
-        data !== null &&
-        "type" in data &&
-        data.type === "__init_config");
-}
-export function handleInitConfig(req, data) {
-    try {
-        if (data.config) {
-            setSDKConfig(data.config);
-        }
-        if (data.runtimeContext) {
-            setRuntimeContext(data.runtimeContext);
-        }
-        req.reply(JSON.stringify({ success: true }), "utf-8");
-    }
-    catch (error) {
-        req.reply(JSON.stringify({
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-        }), "utf-8");
-    }
-}

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

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

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

@@ -1,164 +0,0 @@
-import { models } from "../../../models/registry/models.js";
-import { getAllModelIds, getModelEntry, } from "../../bare/registry/model-registry.js";
-import { getConfiguredCacheDir } from "../../bare/registry/config-registry.js";
-import { generateShortHash } from "../../utils/index.js";
-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 async function handleGetModelInfo(request) {
-    const { name } = request;
-    const catalogEntry = models.find((m) => m.name === name);
-    if (!catalogEntry) {
-        throw new ModelNotFoundError(`${name}" not found in catalog. Use model names from the catalog (e.g., "WHISPER_TINY", "EMBEDDINGGEMMA_300M_Q4_0")`);
-    }
-    const cacheKey = generateShortHash(catalogEntry.registryPath);
-    const cacheStatus = catalogEntry.shardMetadata && catalogEntry.shardMetadata.length > 0
-        ? await handleShardedModel(cacheKey, catalogEntry.shardMetadata)
-        : await handleSingleFileModel(catalogEntry.registryPath, catalogEntry.modelId, catalogEntry.expectedSize, catalogEntry.sha256Checksum);
-    const { cacheFiles, isCached, actualSize, cachedAt } = cacheStatus;
-    const loadedModelIds = getAllModelIds();
-    const loadedInstances = [];
-    for (const id of loadedModelIds) {
-        const entry = getModelEntry(id);
-        if (!entry?.local)
-            continue;
-        const matchesByName = entry.local.name && entry.local.name === name;
-        const matchesByPath = cacheFiles.length > 0 && entry.local.path === cacheFiles[0]?.path;
-        if (matchesByName || matchesByPath) {
-            const instance = {
-                registryId: id,
-                loadedAt: entry.local.loadedAt,
-                config: entry.local.config,
-            };
-            loadedInstances.push(instance);
-        }
-    }
-    const isLoaded = loadedInstances.length > 0;
-    const modelInfo = {
-        name: catalogEntry.name,
-        modelId: catalogEntry.modelId,
-        registryPath: catalogEntry.registryPath,
-        registrySource: catalogEntry.registrySource,
-        blobCoreKey: catalogEntry.blobCoreKey,
-        blobBlockOffset: catalogEntry.blobBlockOffset,
-        blobBlockLength: catalogEntry.blobBlockLength,
-        blobByteOffset: catalogEntry.blobByteOffset,
-        engine: catalogEntry.engine,
-        quantization: catalogEntry.quantization,
-        params: catalogEntry.params,
-        expectedSize: catalogEntry.expectedSize,
-        sha256Checksum: catalogEntry.sha256Checksum,
-        addon: catalogEntry.addon,
-        isCached,
-        isLoaded,
-        cacheFiles,
-        actualSize,
-        cachedAt,
-        loadedInstances: loadedInstances.length > 0 ? loadedInstances : undefined,
-    };
-    return {
-        type: "getModelInfo",
-        modelInfo,
-    };
-}
-async function handleShardedModel(cacheKey, shardMetadata) {
-    const cacheFiles = [];
-    let allShardsCached = true;
-    let totalActualSize = 0;
-    let latestCachedAt;
-    for (const shard of shardMetadata) {
-        const shardPath = getShardPath(cacheKey, shard.filename);
-        let shardIsCached = false;
-        let shardActualSize;
-        let shardCachedAt;
-        try {
-            const stats = await fsPromises.stat(shardPath);
-            const fileExists = stats.isFile();
-            if (fileExists) {
-                shardActualSize = stats.size;
-                shardCachedAt = stats.mtime;
-                shardIsCached = stats.size === shard.expectedSize;
-                if (shardIsCached) {
-                    totalActualSize += stats.size;
-                    if (!latestCachedAt || stats.mtime > latestCachedAt) {
-                        latestCachedAt = stats.mtime;
-                    }
-                }
-                else {
-                    allShardsCached = false;
-                }
-            }
-            else {
-                allShardsCached = false;
-            }
-        }
-        catch {
-            shardIsCached = false;
-            allShardsCached = false;
-        }
-        cacheFiles.push({
-            filename: shard.filename,
-            path: shardPath,
-            expectedSize: shard.expectedSize,
-            sha256Checksum: shard.sha256Checksum,
-            isCached: shardIsCached,
-            actualSize: shardActualSize,
-            cachedAt: shardCachedAt,
-        });
-    }
-    const result = {
-        cacheFiles,
-        isCached: allShardsCached,
-    };
-    if (allShardsCached) {
-        result.actualSize = totalActualSize;
-        if (latestCachedAt) {
-            result.cachedAt = latestCachedAt;
-        }
-    }
-    return result;
-}
-async function handleSingleFileModel(registryPath, modelId, expectedSize, sha256Checksum) {
-    const cacheDir = getConfiguredCacheDir();
-    // Use registryPath for hash to match download logic in registry.ts
-    const sourceHash = generateShortHash(registryPath);
-    const filePath = path.join(cacheDir, `${sourceHash}_${modelId}`);
-    let fileIsCached = false;
-    let fileActualSize;
-    let fileCachedAt;
-    try {
-        const stats = await fsPromises.stat(filePath);
-        const fileExists = stats.isFile();
-        if (fileExists) {
-            fileActualSize = stats.size;
-            fileCachedAt = stats.mtime;
-            fileIsCached = stats.size === expectedSize;
-        }
-    }
-    catch {
-        fileIsCached = false;
-    }
-    const cacheFiles = [
-        {
-            filename: modelId,
-            path: filePath,
-            expectedSize,
-            sha256Checksum,
-            isCached: fileIsCached,
-            actualSize: fileActualSize,
-            cachedAt: fileCachedAt,
-        },
-    ];
-    const result = {
-        cacheFiles,
-        isCached: fileIsCached,
-    };
-    if (fileActualSize !== undefined) {
-        result.actualSize = fileActualSize;
-    }
-    if (fileCachedAt !== undefined) {
-        result.cachedAt = fileCachedAt;
-    }
-    return result;
-}

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

@@ -1,6 +0,0 @@
-import type { ModelProgressUpdate } from "../../../../schemas/index";
-import type { DownloadResult } from "./types";
-export declare function downloadModelFromHttpWithStats(url: string, progressCallback?: (progress: ModelProgressUpdate) => void): Promise<DownloadResult>;
-export declare function downloadModelFromRegistryWithStats(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string): Promise<DownloadResult>;
-export declare function downloadModelFromHyperdriveWithStats(hyperdriveKey: string, modelFileName: string, seed?: boolean, progressCallback?: (progress: ModelProgressUpdate) => void): Promise<DownloadResult>;
-//# sourceMappingURL=download-stats.d.ts.map