@qvac/sdk 0.7.1 → 0.8.1

package/dist/server/rpc/handlers/cancel-delegated.js

@@ -0,0 +1,71 @@
+import { getServerLogger } from "../../../logging/index.js";
+import { getModelEntry } from "../../bare/registry/model-registry.js";
+import { getRPC } from "../../bare/delegate-rpc-client.js";
+import { send } from "../delegate-transport.js";
+const logger = getServerLogger();
+function resolveDelegationTarget(request) {
+    if (request.operation === "inference") {
+        const entry = getModelEntry(request.modelId);
+        if (!entry?.isDelegated || !entry.delegated) {
+            return null;
+        }
+        const target = {
+            topic: entry.delegated.topic,
+            providerPublicKey: entry.delegated.providerPublicKey,
+        };
+        if (entry.delegated.timeout !== undefined) {
+            target.timeout = entry.delegated.timeout;
+        }
+        return target;
+    }
+    if (request.operation === "downloadAsset" && request.delegate) {
+        const target = {
+            topic: request.delegate.topic,
+            providerPublicKey: request.delegate.providerPublicKey,
+        };
+        if (request.delegate.timeout !== undefined) {
+            target.timeout = request.delegate.timeout;
+        }
+        return target;
+    }
+    return null;
+}
+function toProviderCancelRequest(request) {
+    if (request.operation !== "downloadAsset") {
+        return request;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { delegate: _delegate, ...providerRequest } = request;
+    return providerRequest;
+}
+export async function handleCancelDelegated(request, options) {
+    const target = resolveDelegationTarget(request);
+    if (!target) {
+        logger.warn(`Delegated cancel skipped (no delegation target): operation=${request.operation}`);
+        return { type: "cancel", success: true };
+    }
+    try {
+        const rpc = await getRPC(target.topic, target.providerPublicKey, {
+            timeout: target.timeout,
+        });
+        const delegateOpts = {
+            peerKey: target.providerPublicKey,
+        };
+        if (target.timeout !== undefined) {
+            delegateOpts.timeout = target.timeout;
+        }
+        if (options?.profilingMeta) {
+            delegateOpts.profilingMeta = options.profilingMeta;
+        }
+        await send(toProviderCancelRequest(request), rpc, delegateOpts);
+        return { type: "cancel", success: true };
+    }
+    catch (error) {
+        logger.error("Error during delegated cancellation:", error);
+        return {
+            type: "cancel",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

package/dist/server/rpc/handlers/completion-stream-delegated.d.ts

@@ -1,3 +1,5 @@
 import type { CompletionStreamRequest, CompletionStreamResponse } from "../../../schemas/index";
-export declare function handleCompletionStreamDelegated(request: CompletionStreamRequest): AsyncGenerator<CompletionStreamResponse>;
+import type { DelegatedHandlerOptions } from "../profiling/index";
+export type HandleCompletionStreamDelegatedOptions = DelegatedHandlerOptions;
+export declare function handleCompletionStreamDelegated(request: CompletionStreamRequest, options?: HandleCompletionStreamDelegatedOptions): AsyncGenerator<CompletionStreamResponse>;
 //# sourceMappingURL=completion-stream-delegated.d.ts.map

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

@@ -4,19 +4,28 @@ import { stream } from "../delegate-transport.js";
 import { ModelIsDelegatedError } from "../../../utils/errors-server.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
-export async function* handleCompletionStreamDelegated(request) {
+export async function* handleCompletionStreamDelegated(request, options) {
+    const { profilingMeta } = options ?? {};
     // Get delegation info from model registry
     const entry = getModelEntry(request.modelId);
     if (!entry?.isDelegated || !entry.delegated) {
         throw new ModelIsDelegatedError(request.modelId);
     }
-    const { topic, providerPublicKey, timeout } = entry.delegated;
+    const { topic, providerPublicKey, timeout, healthCheckTimeout } = entry.delegated;
     try {
         logger.debug(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
         // Create RPC instance for this HyperSwarm peer
-        const rpc = await getRPC(topic, providerPublicKey, { timeout });
+        const rpc = await getRPC(topic, providerPublicKey, { timeout, healthCheckTimeout });
+        // Build delegate options with profiling metadata
+        const delegateOpts = { peerKey: providerPublicKey };
+        if (profilingMeta) {
+            delegateOpts.profilingMeta = profilingMeta;
+        }
+        if (timeout) {
+            delegateOpts.timeout = timeout;
+        }
         // Use the regular stream function with the HyperSwarm RPC instance
-        const responseStream = stream(request, rpc, { timeout });
+        const responseStream = stream(request, rpc, delegateOpts);
         // Yield each response from the stream
         for await (const response of responseStream) {
             yield response;

package/dist/server/rpc/handlers/download-asset.js

@@ -1,15 +1,67 @@
-import { resolveModelPath } from "./load-model/resolve.js";
+import { PROFILING_KEY, OPERATION_EVENT_KEY, } from "../../../schemas/index.js";
+import { resolveModelPath, resolveModelPathWithStats, } from "./load-model/resolve.js";
+import { nowMs, generateProfileId } from "../../../profiling/clock.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
 export async function handleDownloadAsset(request, progressCallback) {
     const { assetSrc, seed } = request;
+    const profilingMeta = request[PROFILING_KEY];
+    const profilingEnabled = profilingMeta?.enabled !== false && !!profilingMeta;
     try {
-        await resolveModelPath(assetSrc, progressCallback, seed);
-        return {
+        const totalDownloadStart = profilingEnabled ? nowMs() : 0;
+        let sourceType;
+        let downloadStats;
+        if (profilingEnabled) {
+            const result = await resolveModelPathWithStats(assetSrc, progressCallback, seed);
+            sourceType = result.sourceType;
+            downloadStats = result.downloadStats;
+        }
+        else {
+            await resolveModelPath(assetSrc, progressCallback, seed);
+        }
+        const response = {
             type: "downloadAsset",
             success: true,
             assetId: assetSrc,
         };
+        if (profilingEnabled) {
+            const totalDownloadTimeMs = nowMs() - totalDownloadStart;
+            const profileId = profilingMeta?.id ?? generateProfileId();
+            const gauges = {
+                totalDownloadTime: totalDownloadTimeMs,
+            };
+            if (downloadStats) {
+                if (downloadStats.downloadTimeMs !== undefined) {
+                    gauges["downloadTime"] = downloadStats.downloadTimeMs;
+                }
+                if (downloadStats.totalBytesDownloaded !== undefined) {
+                    gauges["totalBytesDownloaded"] = downloadStats.totalBytesDownloaded;
+                }
+                if (downloadStats.downloadSpeedBps !== undefined) {
+                    gauges["downloadSpeedBps"] = downloadStats.downloadSpeedBps;
+                }
+                if (downloadStats.checksumValidationTimeMs !== undefined) {
+                    gauges["checksumValidationTime"] = downloadStats.checksumValidationTimeMs;
+                }
+            }
+            const tags = {};
+            if (sourceType) {
+                tags["sourceType"] = sourceType;
+            }
+            if (downloadStats?.cacheHit !== undefined) {
+                tags["cacheHit"] = downloadStats.cacheHit ? "true" : "false";
+            }
+            const operationEvent = {
+                op: "downloadAsset",
+                kind: "handler",
+                ms: totalDownloadTimeMs,
+                profileId,
+                gauges: Object.keys(gauges).length > 0 ? gauges : undefined,
+                tags: Object.keys(tags).length > 0 ? tags : undefined,
+            };
+            response[OPERATION_EVENT_KEY] = operationEvent;
+        }
+        return response;
     }
     catch (error) {
         logger.error("Error downloading asset:", error);

package/dist/server/rpc/handlers/heartbeat-delegated.d.ts

@@ -0,0 +1,4 @@
+import type { HeartbeatRequest, HeartbeatResponse } from "../../../schemas/index";
+import type { DelegatedHandlerOptions } from "../profiling/index";
+export declare function handleHeartbeatDelegated(request: HeartbeatRequest, options?: DelegatedHandlerOptions): Promise<HeartbeatResponse>;
+//# sourceMappingURL=heartbeat-delegated.d.ts.map

package/dist/server/rpc/handlers/heartbeat-delegated.js

@@ -0,0 +1,32 @@
+import { getServerLogger } from "../../../logging/index.js";
+import { getRPC } from "../../bare/delegate-rpc-client.js";
+import { send } from "../delegate-transport.js";
+import { DelegateConnectionFailedError } from "../../../utils/errors-server.js";
+const logger = getServerLogger();
+export async function handleHeartbeatDelegated(request, options) {
+    const { delegate } = request;
+    if (!delegate) {
+        throw new DelegateConnectionFailedError("Delegated heartbeat handler called without delegate info");
+    }
+    const { topic, providerPublicKey, timeout } = delegate;
+    try {
+        const rpc = await getRPC(topic, providerPublicKey, { timeout });
+        const delegateOpts = {
+            peerKey: providerPublicKey,
+        };
+        if (timeout !== undefined) {
+            delegateOpts.timeout = timeout;
+        }
+        if (options?.profilingMeta) {
+            delegateOpts.profilingMeta = options.profilingMeta;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { delegate: _delegate, ...providerRequest } = request;
+        const response = await send(providerRequest, rpc, delegateOpts);
+        return response;
+    }
+    catch (error) {
+        logger.error("Error during delegated heartbeat:", error);
+        throw error;
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { HeartbeatResponse } from "../../../schemas/index";
+export declare function handleHeartbeat(): HeartbeatResponse;
+//# sourceMappingURL=heartbeat.d.ts.map

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

@@ -0,0 +1,3 @@
+export function handleHeartbeat() {
+    return { type: "heartbeat", number: Math.random() * 100 };
+}

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

@@ -14,11 +14,11 @@ import { handleDeleteCache } from "./delete-cache";
 import { handleTextToSpeech } from "./text-to-speech";
 import { handleGetModelInfo } from "./get-model-info";
 import { handleOCRStream } from "./ocr-stream";
-import { handlePing } from "./ping";
+import { handleHeartbeat } from "./heartbeat";
 import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke";
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from "./registry";
 export declare const handlers: {
-    ping: typeof handlePing;
+    heartbeat: typeof handleHeartbeat;
     completionStream: typeof handleCompletionStream;
     downloadAsset: typeof handleDownloadAsset;
     deleteCache: typeof handleDeleteCache;

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

@@ -14,11 +14,11 @@ 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";
-import { handlePing } from "./ping.js";
+import { handleHeartbeat } from "./heartbeat.js";
 import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke.js";
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./registry.js";
 export const handlers = {
-    ping: handlePing,
+    heartbeat: handleHeartbeat,
     completionStream: handleCompletionStream,
     downloadAsset: handleDownloadAsset,
     deleteCache: handleDeleteCache,

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

@@ -0,0 +1,6 @@
+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

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

@@ -0,0 +1,87 @@
+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,
+        checksumValidationTimeMsTotal: 0,
+    };
+}
+function createHooks(collector) {
+    return {
+        markCacheHit: () => {
+            if (collector.cacheHit === undefined) {
+                collector.cacheHit = true;
+                collector.maxBytesDownloaded = 0;
+            }
+        },
+        markCacheMiss: () => {
+            collector.cacheHit = false;
+        },
+        addChecksumValidationTimeMs: (durationMs) => {
+            collector.checksumValidationTimeMsTotal += durationMs;
+        },
+    };
+}
+function wrapProgressCallback(collector, originalCallback) {
+    return (progress) => {
+        // Don't track bytes for cache hits (they're not real network transfer)
+        if (collector.cacheHit !== true) {
+            const downloaded = progress.onnxInfo?.overallDownloaded ??
+                progress.shardInfo?.overallDownloaded ??
+                progress.downloaded ??
+                0;
+            collector.maxBytesDownloaded = Math.max(collector.maxBytesDownloaded, downloaded);
+        }
+        originalCallback?.(progress);
+    };
+}
+function computeStats(collector) {
+    const downloadTimeMs = nowMs() - collector.startTimeMs;
+    const totalBytesDownloaded = collector.maxBytesDownloaded;
+    const stats = {};
+    if (collector.cacheHit !== undefined) {
+        stats.cacheHit = collector.cacheHit;
+    }
+    if (collector.checksumValidationTimeMsTotal > 0) {
+        stats.checksumValidationTimeMs = collector.checksumValidationTimeMsTotal;
+    }
+    if (collector.cacheHit === true) {
+        return Object.keys(stats).length > 0 ? stats : undefined;
+    }
+    if (totalBytesDownloaded > 0) {
+        stats.downloadTimeMs = downloadTimeMs;
+        stats.totalBytesDownloaded = totalBytesDownloaded;
+        if (downloadTimeMs > 0) {
+            stats.downloadSpeedBps = (totalBytesDownloaded * 1000) / downloadTimeMs;
+        }
+    }
+    return Object.keys(stats).length > 0 ? stats : undefined;
+}
+export async function downloadModelFromHttpWithStats(url, progressCallback) {
+    const collector = createStatsCollector();
+    const hooks = createHooks(collector);
+    const wrappedCallback = wrapProgressCallback(collector, progressCallback);
+    const path = await downloadModelFromHttp(url, wrappedCallback, hooks);
+    const stats = computeStats(collector);
+    return stats ? { path, stats } : { path };
+}
+export async function downloadModelFromRegistryWithStats(registryPath, registrySource, progressCallback, expectedChecksum) {
+    const collector = createStatsCollector();
+    const hooks = createHooks(collector);
+    const wrappedCallback = wrapProgressCallback(collector, progressCallback);
+    const path = await downloadModelFromRegistry(registryPath, registrySource, wrappedCallback, expectedChecksum, hooks);
+    const stats = computeStats(collector);
+    return stats ? { path, stats } : { path };
+}
+export async function downloadModelFromHyperdriveWithStats(hyperdriveKey, modelFileName, seed, progressCallback) {
+    const collector = createStatsCollector();
+    const hooks = createHooks(collector);
+    const wrappedCallback = wrapProgressCallback(collector, progressCallback);
+    const path = await downloadModelFromHyperdrive(hyperdriveKey, modelFileName, seed, wrappedCallback, hooks);
+    const stats = computeStats(collector);
+    return stats ? { path, stats } : { path };
+}

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

@@ -1,112 +1,135 @@
-import { normalizeModelType, ModelType } from "../../../../schemas/index.js";
-import { hyperdriveUrlSchema } from "../../../../schemas/load-model.js";
+import { normalizeModelType, PROFILING_KEY, OPERATION_EVENT_KEY, } from "../../../../schemas/index.js";
 import { loadModel } from "../../../bare/ops/load-model.js";
-import { resolveModelPath } from "./resolve.js";
+import { resolveModelPath, resolveModelPathWithStats, } from "./resolve.js";
+import { nowMs, generateProfileId } from "../../../../profiling/clock.js";
 import { getModelEntry, updateModelConfig, } from "../../../bare/registry/model-registry.js";
-import { generateShortHash, transformConfigForReload } from "../../../utils/index.js";
-import { ConfigReloadNotSupportedError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, } from "../../../../utils/errors-server.js";
+import { generateShortHash, canonicalConfigString, transformConfigForReload, } from "../../../utils/index.js";
+import { ConfigReloadNotSupportedError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, ModelLoadFailedError, PluginLoadConfigValidationFailedError, PluginNotFoundError, } from "../../../../utils/errors-server.js";
 import { getServerLogger } from "../../../../logging/index.js";
-import { OCR_CRAFT_DETECTOR } from "../../../../models/registry/index.js";
 import { getPlugin } from "../../../plugins/index.js";
 const logger = getServerLogger();
-const OCR_DETECTOR_FILENAME = "detector_craft.onnx";
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
 export async function handleLoadModel(request, progressCallback) {
-    // Handle reload config
     if (isReloadConfigRequest(request)) {
         return handleConfigReload(request);
     }
-    // Handle load new model from source
-    const { modelSrc, modelName, seed, projectionModelSrc, vadModelSrc } = request;
+    const { modelSrc, modelName, seed } = request;
     const canonicalModelType = normalizeModelType(request.modelType);
-    const srcVocabSrc = canonicalModelType === ModelType.nmtcppTranslation
-        ? request.srcVocabSrc
-        : undefined;
-    const dstVocabSrc = canonicalModelType === ModelType.nmtcppTranslation
-        ? request.dstVocabSrc
-        : undefined;
-    const detectorModelSrc = canonicalModelType === ModelType.onnxOcr
-        ? request.detectorModelSrc
-        : undefined;
+    const profilingMeta = request[PROFILING_KEY];
+    const profilingEnabled = profilingMeta?.enabled !== false && !!profilingMeta;
     try {
-        const modelPath = await resolveModelPath(modelSrc, progressCallback, seed);
-        let projectionModelPath;
-        if (projectionModelSrc) {
-            projectionModelPath = await resolveModelPath(projectionModelSrc, progressCallback, seed);
+        const plugin = getPlugin(canonicalModelType);
+        if (!plugin) {
+            throw new PluginNotFoundError(canonicalModelType);
         }
-        let vadModelPath;
-        if (vadModelSrc) {
-            vadModelPath = await resolveModelPath(vadModelSrc, progressCallback, seed);
+        let resolvedModelConfig = (request.modelConfig ?? {});
+        const parseResult = plugin.loadConfigSchema.safeParse(resolvedModelConfig);
+        if (!parseResult.success) {
+            const details = parseResult.error.issues
+                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
+                .join(", ");
+            throw new PluginLoadConfigValidationFailedError(canonicalModelType, details);
         }
-        // For OCR models: use provided detectorModelSrc or auto-derive
-        let detectorModelPath;
-        if (canonicalModelType === ModelType.onnxOcr) {
-            if (detectorModelSrc) {
-                detectorModelPath = await resolveModelPath(detectorModelSrc, progressCallback, seed);
-            }
-            else if (modelSrc.startsWith("pear://")) {
-                const { key } = hyperdriveUrlSchema.parse(modelSrc);
-                const derivedDetectorSrc = `pear://${key}/${OCR_DETECTOR_FILENAME}`;
-                detectorModelPath = await resolveModelPath(derivedDetectorSrc, progressCallback, seed);
-            }
-            else if (modelSrc.startsWith("registry://")) {
-                detectorModelPath = await resolveModelPath(OCR_CRAFT_DETECTOR, progressCallback, seed);
-            }
+        resolvedModelConfig = parseResult.data;
+        const totalLoadStart = profilingEnabled ? nowMs() : 0;
+        let resolveResult;
+        let resolvedModelPath;
+        if (profilingEnabled) {
+            resolveResult = await resolveModelPathWithStats(modelSrc, progressCallback, seed);
+            resolvedModelPath = resolveResult.path;
         }
-        // For Bergamot models, resolve vocabulary sources to local paths
-        if (canonicalModelType === ModelType.nmtcppTranslation &&
-            request.modelConfig) {
-            const nmtConfig = request.modelConfig;
-            if (nmtConfig.engine === "Bergamot") {
-                let resolvedSrcVocabSrc = srcVocabSrc;
-                let resolvedDstVocabSrc = dstVocabSrc;
-                if (!srcVocabSrc || !dstVocabSrc) {
-                    const derivedVocabSrcs = modelSrc.startsWith("pear://")
-                        ? deriveBergamotVocabSources(modelSrc)
-                        : modelSrc.startsWith("registry://")
-                            ? deriveBergamotRegistryVocabSources(modelSrc)
-                            : null;
-                    if (derivedVocabSrcs) {
-                        resolvedSrcVocabSrc = srcVocabSrc ?? derivedVocabSrcs.srcVocabSrc;
-                        resolvedDstVocabSrc = dstVocabSrc ?? derivedVocabSrcs.dstVocabSrc;
-                    }
-                }
-                if (resolvedSrcVocabSrc) {
-                    nmtConfig.srcVocabPath = await resolveModelPath(resolvedSrcVocabSrc, progressCallback, seed);
-                }
-                if (resolvedDstVocabSrc) {
-                    nmtConfig.dstVocabPath = await resolveModelPath(resolvedDstVocabSrc, progressCallback, seed);
-                }
-            }
+        else {
+            resolvedModelPath = await resolveModelPath(modelSrc, progressCallback, seed);
         }
-        // Use plugin's resolveConfig hook if available to resolve model sources
-        let resolvedModelConfig = request.modelConfig;
-        const plugin = getPlugin(canonicalModelType);
-        if (plugin?.resolveConfig && resolvedModelConfig) {
-            const resolve = (src) => resolveModelPath(src, progressCallback, seed);
-            resolvedModelConfig = await plugin.resolveConfig(resolvedModelConfig, resolve);
+        let pluginArtifacts = {};
+        if (plugin.resolveConfig) {
+            const ctx = {
+                resolveModelPath: (src) => resolveModelPath(src, progressCallback, seed),
+                modelSrc,
+                modelType: canonicalModelType,
+                ...(modelName !== undefined && { modelName }),
+            };
+            const result = await plugin.resolveConfig(resolvedModelConfig, ctx);
+            resolvedModelConfig = result.config;
+            if (result.artifacts) {
+                pluginArtifacts = result.artifacts;
+            }
         }
-        // Generate hash-based modelId from modelConfig (includes all sources for TTS)
-        const configStr = JSON.stringify(request.modelConfig, Object.keys(request.modelConfig).sort());
+        const configStr = canonicalConfigString(request.modelConfig);
         const modelHashInput = `${request.modelType}:${modelSrc}:${configStr}`;
         const modelId = generateShortHash(modelHashInput);
-        const loadModelOptions = {
-            ...request,
-            modelConfig: resolvedModelConfig,
-        };
-        await loadModel({
+        if ("modelPath" in pluginArtifacts) {
+            logger.warn("Plugin returned 'modelPath' artifact which was overridden by core");
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { modelPath: _, ...artifacts } = pluginArtifacts;
+        if (!resolvedModelPath) {
+            throw new ModelLoadFailedError("modelPath resolution failed");
+        }
+        const loadResult = await loadModel({
             modelId,
-            modelPath,
-            options: loadModelOptions,
-            projectionModelPath,
-            vadModelPath,
-            detectorModelPath,
+            modelPath: resolvedModelPath,
+            options: {
+                ...request,
+                modelType: canonicalModelType,
+                modelConfig: resolvedModelConfig,
+            },
+            artifacts: Object.keys(artifacts).length > 0 ? artifacts : undefined,
             modelName,
-        });
-        return {
+        }, profilingEnabled ? { collectTiming: true } : undefined);
+        const response = {
             type: "loadModel",
             success: true,
             modelId,
         };
+        if (profilingEnabled) {
+            const totalLoadTimeMs = nowMs() - totalLoadStart;
+            const profileId = profilingMeta?.id ?? generateProfileId();
+            const gauges = {
+                totalLoadTime: totalLoadTimeMs,
+            };
+            if (loadResult.timing?.modelInitializationTimeMs !== undefined) {
+                gauges["modelInitializationTime"] =
+                    loadResult.timing.modelInitializationTimeMs;
+            }
+            if (resolveResult?.downloadStats) {
+                const ds = resolveResult.downloadStats;
+                if (ds.downloadTimeMs !== undefined) {
+                    gauges["downloadTime"] = ds.downloadTimeMs;
+                }
+                if (ds.totalBytesDownloaded !== undefined) {
+                    gauges["totalBytesDownloaded"] = ds.totalBytesDownloaded;
+                }
+                if (ds.downloadSpeedBps !== undefined) {
+                    gauges["downloadSpeedBps"] = ds.downloadSpeedBps;
+                }
+                if (ds.checksumValidationTimeMs !== undefined) {
+                    gauges["checksumValidationTime"] = ds.checksumValidationTimeMs;
+                }
+            }
+            const tags = {};
+            if (canonicalModelType) {
+                tags["modelType"] = canonicalModelType;
+            }
+            if (resolveResult?.sourceType) {
+                tags["sourceType"] = resolveResult.sourceType;
+            }
+            if (resolveResult?.downloadStats?.cacheHit !== undefined) {
+                tags["cacheHit"] = resolveResult.downloadStats.cacheHit ? "true" : "false";
+            }
+            const operationEvent = {
+                op: "loadModel",
+                kind: "handler",
+                ms: totalLoadTimeMs,
+                profileId,
+                gauges: Object.keys(gauges).length > 0 ? gauges : undefined,
+                tags: Object.keys(tags).length > 0 ? tags : undefined,
+            };
+            response[OPERATION_EVENT_KEY] = operationEvent;
+        }
+        return response;
     }
     catch (error) {
         logger.error("Error loading model:", error);
@@ -162,41 +185,3 @@ async function handleConfigReload(request) {
 function isReloadConfigRequest(request) {
     return "modelId" in request && !("modelSrc" in request);
 }
-const BERGAMOT_CJK_LANG_PAIRS = ["enja", "enko", "enzh"];
-function deriveBergamotVocabSources(modelSrc) {
-    const match = modelSrc.match(/^pear:\/\/([a-f0-9]+)\/model\.([a-z]+)\.intgemm\.alphas\.bin$/);
-    if (!match || !match[1] || !match[2])
-        return null;
-    const key = match[1];
-    const langPair = match[2];
-    if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
-        return {
-            srcVocabSrc: `pear://${key}/srcvocab.${langPair}.spm`,
-            dstVocabSrc: `pear://${key}/trgvocab.${langPair}.spm`,
-        };
-    }
-    const sharedVocab = `pear://${key}/vocab.${langPair}.spm`;
-    return {
-        srcVocabSrc: sharedVocab,
-        dstVocabSrc: sharedVocab,
-    };
-}
-function deriveBergamotRegistryVocabSources(modelSrc) {
-    // registry://s3/path/to/model.enfr.intgemm.alphas.bin
-    const match = modelSrc.match(/^(registry:\/\/.+\/)model\.([a-z]+)\.intgemm\.alphas\.bin$/);
-    if (!match || !match[1] || !match[2])
-        return null;
-    const basePath = match[1];
-    const langPair = match[2];
-    if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
-        return {
-            srcVocabSrc: `${basePath}srcvocab.${langPair}.spm`,
-            dstVocabSrc: `${basePath}trgvocab.${langPair}.spm`,
-        };
-    }
-    const sharedVocab = `${basePath}vocab.${langPair}.spm`;
-    return {
-        srcVocabSrc: sharedVocab,
-        dstVocabSrc: sharedVocab,
-    };
-}

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

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