@qvac/sdk 0.14.0 → 0.15.0

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

@@ -1,7 +1,8 @@
-import type { ModelProgressUpdate } from "../../../../schemas/index";
-import type { DownloadStats, DownloadResult, DownloadHooks, ResolveResult } from "./types";
+import type { ModelProgressUpdate } from '../../../../schemas/index';
+import type { DownloadStats, DownloadResult, DownloadHooks, ResolveResult } from './types';
+import type { ExplicitRegistryMetadata } from './registry-metadata';
 export declare function downloadModelFromHttpWithStats(url: string, progressCallback?: (progress: ModelProgressUpdate) => void, downloadHooks?: DownloadHooks): Promise<DownloadResult>;
-export declare function downloadModelFromRegistryWithStats(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string, downloadHooks?: DownloadHooks): Promise<DownloadResult>;
+export declare function downloadModelFromRegistryWithStats(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string, downloadHooks?: DownloadHooks, explicitMetadata?: ExplicitRegistryMetadata): Promise<DownloadResult>;
 export declare function downloadModelFromHyperdriveWithStats(hyperdriveKey: string, modelFileName: string, seed?: boolean, progressCallback?: (progress: ModelProgressUpdate) => void, downloadHooks?: DownloadHooks): Promise<DownloadResult>;
 export declare function mergeDownloadStats(results: ResolveResult[]): DownloadStats | undefined;
 //# sourceMappingURL=download-stats.d.ts.map

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

@@ -1,14 +1,14 @@
-import { downloadModelFromHttp } from "./http.js";
-import { downloadModelFromRegistry } from "./registry.js";
-import { downloadModelFromHyperdrive } from "./hyperdrive.js";
-import { nowMs } from "../../../../profiling/index.js";
+import { downloadModelFromHttp } from './http.js';
+import { downloadModelFromRegistry } from './registry.js';
+import { downloadModelFromHyperdrive } from './hyperdrive.js';
+import { nowMs } from '../../../../profiling/index.js';
 function createStatsCollector() {
     return {
         maxBytesDownloaded: 0,
         startTimeMs: nowMs(),
         cacheHit: undefined,
         sharedTransfer: false,
-        checksumValidationTimeMsTotal: 0,
+        checksumValidationTimeMsTotal: 0
     };
 }
 function createStatsHooks(collector) {
@@ -27,7 +27,7 @@ function createStatsHooks(collector) {
         },
         addChecksumValidationTimeMs: (durationMs) => {
             collector.checksumValidationTimeMsTotal += durationMs;
-        },
+        }
     };
 }
 function wrapProgressCallback(collector, originalCallback) {
@@ -82,11 +82,11 @@ export async function downloadModelFromHttpWithStats(url, progressCallback, down
     const stats = computeStats(collector);
     return stats ? { path, stats } : { path };
 }
-export async function downloadModelFromRegistryWithStats(registryPath, registrySource, progressCallback, expectedChecksum, downloadHooks) {
+export async function downloadModelFromRegistryWithStats(registryPath, registrySource, progressCallback, expectedChecksum, downloadHooks, explicitMetadata) {
     const collector = createStatsCollector();
     const hooks = { ...downloadHooks, ...createStatsHooks(collector) };
     const wrappedCallback = wrapProgressCallback(collector, progressCallback);
-    const path = await downloadModelFromRegistry(registryPath, registrySource, wrappedCallback, expectedChecksum, hooks);
+    const path = await downloadModelFromRegistry(registryPath, registrySource, wrappedCallback, expectedChecksum, hooks, explicitMetadata);
     const stats = computeStats(collector);
     return stats ? { path, stats } : { path };
 }
@@ -107,9 +107,7 @@ export function mergeDownloadStats(results) {
     const downloadTimeMs = Math.max(...stats.map((s) => s.downloadTimeMs ?? 0));
     const totalBytesDownloaded = stats.reduce((sum, s) => sum + (s.totalBytesDownloaded ?? 0), 0);
     const checksumValidationTimeMs = stats.reduce((sum, s) => sum + (s.checksumValidationTimeMs ?? 0), 0);
-    const cacheHitValues = stats
-        .map((s) => s.cacheHit)
-        .filter((v) => v !== undefined);
+    const cacheHitValues = stats.map((s) => s.cacheHit).filter((v) => v !== undefined);
     const merged = {};
     if (downloadTimeMs > 0)
         merged.downloadTimeMs = downloadTimeMs;

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

@@ -1,3 +1,3 @@
-import type { LoadModelRequest, LoadModelResponse, ModelProgressUpdate } from "../../../../schemas/index";
+import type { LoadModelRequest, LoadModelResponse, ModelProgressUpdate } from '../../../../schemas/index';
 export declare function handleLoadModel(request: LoadModelRequest, progressCallback?: (update: ModelProgressUpdate) => void): Promise<LoadModelResponse>;
 //# sourceMappingURL=handler.d.ts.map

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

@@ -50,19 +50,19 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { normalizeModelType, PROFILING_KEY, OPERATION_EVENT_KEY, } from "../../../../schemas/index.js";
-import { loadModel } from "../../../bare/ops/load-model.js";
-import { createResolveSession } from "./resolve-session.js";
-import { nowMs, generateProfileId } from "../../../../profiling/clock.js";
-import { getModelEntry, updateModelConfig, } from "../../../bare/registry/model-registry.js";
-import { generateShortHash, canonicalConfigString, transformConfigForReload, } from "../../../utils/index.js";
-import { buildDownloadProfilingFields } from "./types.js";
-import { ConfigReloadNotSupportedError, InferenceCancelledError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, ModelLoadFailedError, PluginLoadConfigValidationFailedError, PluginNotFoundError, } from "../../../../utils/errors-server.js";
-import { getServerLogger } from "../../../../logging/index.js";
-import { formatZodError } from "../../../../utils/zod-error.js";
-import { getPlugin } from "../../../plugins/index.js";
-import { getRequestRegistry, withRequestContext, } from "../../../bare/runtime/index.js";
-import { generateServerRequestId } from "../../../bare/runtime/request-id.js";
+import { normalizeModelType, PROFILING_KEY, OPERATION_EVENT_KEY } from '../../../../schemas/index.js';
+import { loadModel } from '../../../bare/ops/load-model.js';
+import { createResolveSession } from './resolve-session.js';
+import { nowMs, generateProfileId } from '../../../../profiling/clock.js';
+import { getModelEntry, updateModelConfig } from '../../../bare/registry/model-registry.js';
+import { generateShortHash, canonicalConfigString, transformConfigForReload } from '../../../utils/index.js';
+import { buildDownloadProfilingFields } from './types.js';
+import { ConfigReloadNotSupportedError, InferenceCancelledError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, ModelLoadFailedError, PluginLoadConfigValidationFailedError, PluginNotFoundError } from '../../../../utils/errors-server.js';
+import { getServerLogger } from '../../../../logging/index.js';
+import { formatZodError } from '../../../../utils/zod-error.js';
+import { getPlugin } from '../../../plugins/index.js';
+import { getRequestRegistry, withRequestContext } from '../../../bare/runtime/index.js';
+import { generateServerRequestId } from '../../../bare/runtime/request-id.js';
 const logger = getServerLogger();
 // ---------------------------------------------------------------------------
 // Handler
@@ -85,16 +85,16 @@ export async function handleLoadModel(request, progressCallback) {
         // half-built entry). Cancel-by-`requestId` works from `begin(...)` on.
         const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
             requestId,
-            kind: "loadModel",
+            kind: 'loadModel'
         }), true);
         const log = withRequestContext(getServerLogger(), ctx);
-        log.debug(`loadModel start modelSrc=${String(modelSrc ?? "")}`);
+        log.debug(`loadModel start modelSrc=${String(modelSrc ?? '')}`);
         try {
             const plugin = getPlugin(canonicalModelType);
             if (!plugin) {
                 throw new PluginNotFoundError(canonicalModelType);
             }
-            let resolvedModelConfig = (request.modelConfig ?? {});
+            let resolvedModelConfig = request.modelConfig ?? {};
             const parseResult = plugin.loadConfigSchema.safeParse(resolvedModelConfig);
             if (!parseResult.success) {
                 throw new PluginLoadConfigValidationFailedError(canonicalModelType, formatZodError(parseResult.error));
@@ -109,8 +109,8 @@ export async function handleLoadModel(request, progressCallback) {
                 requestBinding: {
                     signal: ctx.signal,
                     scope: ctx.scope,
-                    requestId,
-                },
+                    requestId
+                }
             });
             const primaryResolve = session.resolvePrimaryModelPath(modelSrc);
             let resolvedModelPath;
@@ -146,14 +146,14 @@ export async function handleLoadModel(request, progressCallback) {
                     pluginArtifacts = pluginResolveResult.artifacts;
                 }
             }
-            if ("modelPath" in pluginArtifacts) {
-                throw new ModelLoadFailedError("Plugin returned reserved key \"modelPath\" in artifacts; primary model resolution is core-owned");
+            if ('modelPath' in pluginArtifacts) {
+                throw new ModelLoadFailedError('Plugin returned reserved key "modelPath" in artifacts; primary model resolution is core-owned');
             }
             // An empty resolved path is legitimate when the plugin opts out of
             // primary-model-path validation (bundled weights). For every other
             // plugin, an empty path means resolution failed and we must abort.
             if (!resolvedModelPath && !plugin.skipPrimaryModelPathValidation) {
-                throw new ModelLoadFailedError("modelPath resolution failed");
+                throw new ModelLoadFailedError('modelPath resolution failed');
             }
             const loadResult = await loadModel({
                 modelId,
@@ -161,10 +161,10 @@ export async function handleLoadModel(request, progressCallback) {
                 options: {
                     ...request,
                     modelType: canonicalModelType,
-                    modelConfig: resolvedModelConfig,
+                    modelConfig: resolvedModelConfig
                 },
                 artifacts: Object.keys(pluginArtifacts).length > 0 ? pluginArtifacts : undefined,
-                modelName,
+                modelName
             }, profilingEnabled ? { collectTiming: true } : undefined);
             // Load phase soft-cancel limitation: `plugin.createModel(...)` and
             // `model.load(false)` ran without a signal. A cancel that arrived
@@ -179,30 +179,29 @@ export async function handleLoadModel(request, progressCallback) {
                 throw new InferenceCancelledError(requestId);
             }
             const response = {
-                type: "loadModel",
+                type: 'loadModel',
                 success: true,
-                modelId,
+                modelId
             };
             if (profilingEnabled) {
                 const totalLoadTimeMs = nowMs() - totalLoadStart;
                 const profileId = profilingMeta?.id ?? generateProfileId();
                 const resolveResult = session.getAggregateResult();
                 const { gauges, tags } = buildDownloadProfilingFields(resolveResult?.downloadStats, resolveResult?.sourceType);
-                gauges["totalLoadTime"] = totalLoadTimeMs;
+                gauges['totalLoadTime'] = totalLoadTimeMs;
                 if (loadResult.timing?.modelInitializationTimeMs !== undefined) {
-                    gauges["modelInitializationTime"] =
-                        loadResult.timing.modelInitializationTimeMs;
+                    gauges['modelInitializationTime'] = loadResult.timing.modelInitializationTimeMs;
                 }
                 if (canonicalModelType) {
-                    tags["modelType"] = canonicalModelType;
+                    tags['modelType'] = canonicalModelType;
                 }
                 const operationEvent = {
-                    op: "loadModel",
-                    kind: "handler",
+                    op: 'loadModel',
+                    kind: 'handler',
                     ms: totalLoadTimeMs,
                     profileId,
                     gauges: Object.keys(gauges).length > 0 ? gauges : undefined,
-                    tags: Object.keys(tags).length > 0 ? tags : undefined,
+                    tags: Object.keys(tags).length > 0 ? tags : undefined
                 };
                 response[OPERATION_EVENT_KEY] = operationEvent;
             }
@@ -219,11 +218,11 @@ export async function handleLoadModel(request, progressCallback) {
                 log.info(`loadModel cancelled requestId=${requestId}`);
                 throw error;
             }
-            logger.error("Error loading model:", error);
+            logger.error('Error loading model:', error);
             return {
-                type: "loadModel",
+                type: 'loadModel',
                 success: false,
-                error: error instanceof Error ? error.message : "Unknown error",
+                error: error instanceof Error ? error.message : 'Unknown error'
             };
         }
     }
@@ -254,31 +253,31 @@ async function handleConfigReload(request) {
         }
         const model = entry.local.model;
         const currentConfig = entry.local.config;
-        if (typeof model.reload !== "function") {
+        if (typeof model.reload !== 'function') {
             throw new ConfigReloadNotSupportedError(modelId);
         }
         const mergedConfig = {
             ...currentConfig,
-            ...modelConfig,
+            ...modelConfig
         };
         const reloadConfig = transformConfigForReload(storedModelType, mergedConfig);
         await model.reload(reloadConfig);
         updateModelConfig(modelId, mergedConfig);
         return {
-            type: "loadModel",
+            type: 'loadModel',
             success: true,
-            modelId,
+            modelId
         };
     }
     catch (error) {
-        logger.error("Error reloading config:", error);
+        logger.error('Error reloading config:', error);
         return {
-            type: "loadModel",
+            type: 'loadModel',
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: error instanceof Error ? error.message : 'Unknown error'
         };
     }
 }
 function isReloadConfigRequest(request) {
-    return "modelId" in request && !("modelSrc" in request);
+    return 'modelId' in request && !('modelSrc' in request);
 }

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

@@ -1,4 +1,4 @@
-import type { ModelProgressUpdate } from "../../../../schemas/index";
-import type { DownloadHooks } from "./types";
+import type { ModelProgressUpdate } from '../../../../schemas/index';
+import type { DownloadHooks } from './types';
 export declare function downloadModelFromHttp(url: string, progressCallback?: (progress: ModelProgressUpdate) => void, hooks?: DownloadHooks): Promise<string>;
 //# sourceMappingURL=http.d.ts.map