@qvac/sdk 0.9.1 → 0.10.0

package/dist/server/bare/utils/transcribe-metadata.d.ts

@@ -0,0 +1,21 @@
+import { type TranscribeSegment } from "../../../schemas/index";
+export interface WhisperAddonSegment {
+    text: string;
+    start?: number;
+    end?: number;
+    toAppend?: boolean;
+    id?: number;
+}
+/**
+ * Normalize a native whisper-addon segment to the SDK-level `TranscribeSegment`
+ * shape exposed to callers: seconds → milliseconds, `toAppend` → `append`,
+ * and defaults for optional fields.
+ */
+export declare function toTranscribeSegment(chunk: WhisperAddonSegment): TranscribeSegment;
+/**
+ * Guard used by transcription ops when the caller opts into `metadata: true`.
+ * Only the whisper engine emits per-segment metadata; any other engine
+ * requesting metadata is rejected with `TranscriptionFailedError`.
+ */
+export declare function assertMetadataSupported(modelId: string, engineType: string, metadata: boolean | undefined): void;
+//# sourceMappingURL=transcribe-metadata.d.ts.map

package/dist/server/bare/utils/transcribe-metadata.js

@@ -0,0 +1,28 @@
+import { ModelType } from "../../../schemas/index.js";
+import { TranscriptionFailedError } from "../../../utils/errors-server.js";
+/**
+ * Normalize a native whisper-addon segment to the SDK-level `TranscribeSegment`
+ * shape exposed to callers: seconds → milliseconds, `toAppend` → `append`,
+ * and defaults for optional fields.
+ */
+export function toTranscribeSegment(chunk) {
+    return {
+        text: chunk.text,
+        startMs: (chunk.start ?? 0) * 1000,
+        endMs: (chunk.end ?? 0) * 1000,
+        append: chunk.toAppend ?? false,
+        id: chunk.id ?? 0,
+    };
+}
+/**
+ * Guard used by transcription ops when the caller opts into `metadata: true`.
+ * Only the whisper engine emits per-segment metadata; any other engine
+ * requesting metadata is rejected with `TranscriptionFailedError`.
+ */
+export function assertMetadataSupported(modelId, engineType, metadata) {
+    if (!metadata)
+        return;
+    if (engineType !== ModelType.whispercppTranscription) {
+        throw new TranscriptionFailedError(`metadata mode is not supported on model ${modelId} (engine: ${engineType || "unknown"}); only the whisper engine supports metadata`);
+    }
+}

package/dist/server/bare/utils/tts-stats.d.ts

@@ -0,0 +1,22 @@
+import type { TtsStats } from "../../../schemas/index";
+/**
+ * Shared types and utilities for TTS operations.
+ * Used by both text-to-speech.ts and text-to-speech-stream.ts.
+ */
+export type TtsStreamChunk = {
+    outputArray: ArrayLike<number>;
+    chunkIndex?: number;
+    sentenceChunk?: string;
+};
+export type TtsOpYield = {
+    buffer: number[];
+    chunkIndex?: number;
+    sentenceChunk?: string;
+};
+export declare function collectTtsStats(response: {
+    stats?: {
+        audioDurationMs?: number;
+        totalSamples?: number;
+    };
+}): TtsStats;
+//# sourceMappingURL=tts-stats.d.ts.map

package/dist/server/bare/utils/tts-stats.js

@@ -0,0 +1,10 @@
+export function collectTtsStats(response) {
+    return {
+        ...(response.stats?.audioDurationMs !== undefined && {
+            audioDuration: response.stats.audioDurationMs,
+        }),
+        ...(response.stats?.totalSamples !== undefined && {
+            totalSamples: response.stats.totalSamples,
+        }),
+    };
+}

package/dist/server/rpc/create-server.d.ts

@@ -1,4 +1,7 @@
 import RPC from "bare-rpc";
 export declare function createBareKitRPCServer(): RPC;
-export declare function createIPCClient(socketPath: string): RPC;
+export interface IPCClientOptions {
+    onDisconnect?: () => void;
+}
+export declare function createIPCClient(socketPath: string, options?: IPCClientOptions): RPC;
 //# sourceMappingURL=create-server.d.ts.map

package/dist/server/rpc/create-server.js

@@ -8,7 +8,7 @@ export function createBareKitRPCServer() {
         .BareKit;
     return new RPC(IPC, handleRequest);
 }
-export function createIPCClient(socketPath) {
+export function createIPCClient(socketPath, options) {
     logger.info(`Connecting to IPC socket at ${socketPath}`);
     const socket = connect(socketPath);
     socket.on("connect", () => {
@@ -17,5 +17,9 @@ export function createIPCClient(socketPath) {
     socket.on("error", (err) => {
         logger.error("IPC client connection error:", err);
     });
+    socket.on("close", () => {
+        logger.warn("IPC socket closed — parent process likely terminated");
+        options?.onDisconnect?.();
+    });
     return new RPC(socket, handleRequest);
 }

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

@@ -4,8 +4,8 @@
  * 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 { requestSchema, responseSchema, PROFILING_KEY, PROFILING_TRAILER_KEY, DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, } from "../../schemas/index.js";
+import { nowMs, extractProfilingMeta, stripProfilingMeta, 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";
@@ -48,7 +48,8 @@ async function sendBase(request, rpc, options, profilingMeta) {
         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() || "{}"));
+        const rawPayload = JSON.parse(response?.toString() || "{}");
+        const resPayload = responseSchema.parse(stripProfilingMeta(rawPayload));
         logger.debug("[delegate-transport] Response:", { type: resPayload.type });
         checkAndThrowError(resPayload);
         return resPayload;
@@ -92,12 +93,13 @@ async function sendProfiled(request, rpc, options, profilingMeta) {
         const parseStart = nowMs();
         const rawPayload = JSON.parse(response?.toString() || "{}");
         timings.responseJsonParseMs = nowMs() - parseStart;
-        const resPayload = responseSchema.parse(rawPayload);
+        const serverMeta = extractProfilingMeta(rawPayload);
+        const cleanPayload = stripProfilingMeta(rawPayload);
+        const resPayload = responseSchema.parse(cleanPayload);
         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) {
@@ -150,11 +152,14 @@ async function* streamBase(request, rpc, options = {}, profilingMeta) {
             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;
-                }
+                if (!line.trim())
+                    continue;
+                const rawPayload = JSON.parse(line);
+                if (rawPayload[PROFILING_TRAILER_KEY] === true)
+                    continue;
+                const response = responseSchema.parse(stripProfilingMeta(rawPayload));
+                checkAndThrowError(response);
+                yield response;
             }
         }
     }
@@ -198,26 +203,28 @@ async function* streamProfiled(request, rpc, options = {}, profilingMeta) {
             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;
+                if (!line.trim())
+                    continue;
+                const rawPayload = JSON.parse(line);
+                const serverMeta = extractProfilingMeta(rawPayload);
+                if (serverMeta) {
+                    lastServerMeta = serverMeta;
+                }
+                if (rawPayload[PROFILING_TRAILER_KEY] === true)
+                    continue;
+                const response = responseSchema.parse(stripProfilingMeta(rawPayload));
+                checkAndThrowError(response);
+                timings.chunkCount++;
+                if (timings.firstChunkAt === undefined) {
+                    timings.firstChunkAt = nowMs();
+                }
+                timings.lastChunkAt = nowMs();
+                if (serverMeta?.operation) {
+                    response[OPERATION_EVENT_KEY] = serverMeta.operation;
                 }
+                response[DELEGATION_BREAKDOWN_KEY] =
+                    buildDelegationStreamBreakdown(timings);
+                yield response;
             }
         }
         recordDelegationStreamEvents(timings, lastServerMeta);

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

@@ -4,11 +4,15 @@ import { resolveModelConfig } from "../bare/registry/model-config-registry.js";
 import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
 import { RPCUnknownRequestTypeError, PluginHandlerTypeMismatchError, } from "../../utils/errors-server.js";
 import { registry } from "./handler-registry.js";
-import { executeHandler, executeDuplexHandler, handleInitConfig, isInitConfigMessage, } from "./handler-utils.js";
+import { executeHandler, executeDuplexHandler, handleInitConfig, isInitConfigMessage, handleShutdown, isShutdownMessage, } from "./handler-utils.js";
 import { createServerProfiler } from "./profiling/index.js";
+import { assertLifecycleAllowed } from "../bare/runtime-lifecycle.js";
+import { shouldUseStreamErrorTransport } from "./transport-selector.js";
 export async function handleRequest(req) {
     let profiler;
     let validationStart = 0;
+    let rawRequest;
+    let entry;
     try {
         const rawData = req.data?.toString();
         // Duplex stream request: metadata arrives as the first chunk on the
@@ -27,7 +31,21 @@ export async function handleRequest(req) {
             handleInitConfig(req, jsonData);
             return;
         }
+        // Handle internal pre-terminate cleanup signal (bypasses schema). Lets
+        // the client tear addons down while the JS env is still alive so static
+        // js_ref_t state doesn't survive into the next worklet's isolate.
+        if (isShutdownMessage(jsonData)) {
+            await handleShutdown(req);
+            return;
+        }
         const { data: cleanData, profilingMeta } = extractProfilingMeta(jsonData);
+        if (cleanData && typeof cleanData === "object") {
+            rawRequest = cleanData;
+            const rawType = rawRequest["type"];
+            if (typeof rawType === "string") {
+                entry = registry[rawType];
+            }
+        }
         profiler = createServerProfiler(profilingMeta);
         profiler.markRequestParsed(jsonParseMs);
         validationStart = nowMs();
@@ -36,7 +54,8 @@ export async function handleRequest(req) {
         attachProfilingMetaToRequest(request, profilingMeta);
         profiler.markRequestValidated(nowMs() - validationStart);
         validationStart = 0;
-        const entry = registry[request.type];
+        assertLifecycleAllowed(request);
+        entry = registry[request.type];
         if (!entry) {
             throw new RPCUnknownRequestTypeError(request.type);
         }
@@ -46,7 +65,12 @@ export async function handleRequest(req) {
         if (profiler && validationStart > 0) {
             profiler.markRequestValidated(nowMs() - validationStart);
         }
-        sendErrorResponse(req, error, profiler);
+        if (shouldUseStreamErrorTransport(entry, rawRequest)) {
+            sendStreamErrorResponse(req.createResponseStream(), error, profiler);
+        }
+        else {
+            sendErrorResponse(req, error, profiler);
+        }
     }
 }
 function attachProfilingMetaToRequest(request, profilingMeta) {
@@ -99,6 +123,7 @@ async function handleDuplexRequest(req) {
         const request = requestSchema.parse(processedData);
         attachProfilingMetaToRequest(request, profilingMeta);
         profiler.markRequestValidated(nowMs() - validationStart);
+        assertLifecycleAllowed(request);
         const entry = registry[request.type];
         if (!entry) {
             throw new RPCUnknownRequestTypeError(request.type);

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

@@ -18,7 +18,9 @@ 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 { handleTextToSpeechStream } from "./handlers/text-to-speech-stream.js";
 import { handleGetModelInfo } from "./handlers/get-model-info.js";
+import { handleGetLoadedModelInfo } from "./handlers/get-loaded-model-info.js";
 import { handleOCRStream } from "./handlers/ocr-stream.js";
 import { handleHeartbeat } from "./handlers/heartbeat.js";
 import { handleFinetune } from "./handlers/finetune.js";
@@ -29,6 +31,7 @@ import { handlePluginInvoke, handlePluginInvokeStream, } from "./handlers/plugin
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./handlers/registry.js";
 import { handleSuspend } from "./handlers/suspend.js";
 import { handleResume } from "./handlers/resume.js";
+import { handleState } from "./handlers/state.js";
 function ragSupportsProgress(request) {
     if (request.type !== "rag")
         return false;
@@ -48,7 +51,7 @@ function isModelDelegated(request) {
 function isCancelDelegated(request) {
     if (request.type !== "cancel")
         return false;
-    if (request.operation === "inference") {
+    if (request.operation === "inference" || request.operation === "embeddings") {
         return isModelDelegated(request);
     }
     if (request.operation === "downloadAsset") {
@@ -81,6 +84,7 @@ export const registry = {
     stopProvide: { type: "reply", handler: stopProvideHandler },
     deleteCache: { type: "reply", handler: handleDeleteCache },
     getModelInfo: { type: "reply", handler: handleGetModelInfo },
+    getLoadedModelInfo: { type: "reply", handler: handleGetLoadedModelInfo },
     pluginInvoke: { type: "reply", handler: handlePluginInvoke },
     modelRegistryList: { type: "reply", handler: handleModelRegistryList },
     modelRegistrySearch: { type: "reply", handler: handleModelRegistrySearch },
@@ -90,12 +94,14 @@ export const registry = {
     },
     suspend: { type: "reply", handler: handleSuspend },
     resume: { type: "reply", handler: handleResume },
+    state: { type: "reply", handler: handleState },
     // Simple Stream handlers
     transcribe: { type: "stream", handler: handleTranscribe },
     transcribeStream: { type: "duplex", handler: handleTranscribeStream },
     loggingStream: { type: "stream", handler: handleLoggingStream },
     translate: { type: "stream", handler: handleTranslate },
     textToSpeech: { type: "stream", handler: handleTextToSpeech },
+    textToSpeechStream: { type: "duplex", handler: handleTextToSpeechStream },
     ocrStream: { type: "stream", handler: handleOCRStream },
     diffusionStream: { type: "stream", handler: handleDiffusionStream },
     pluginInvokeStream: { type: "stream", handler: handlePluginInvokeStream },

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

@@ -21,5 +21,10 @@ type InitConfigMessage = {
 };
 export declare function isInitConfigMessage(data: unknown): data is InitConfigMessage;
 export declare function handleInitConfig(req: RPC.IncomingRequest, data: InitConfigMessage): void;
+type ShutdownMessage = {
+    type: "__shutdown__";
+};
+export declare function isShutdownMessage(data: unknown): data is ShutdownMessage;
+export declare function handleShutdown(req: RPC.IncomingRequest): Promise<void>;
 export {};
 //# sourceMappingURL=handler-utils.d.ts.map

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

@@ -170,3 +170,25 @@ export function handleInitConfig(req, data) {
         }), "utf-8");
     }
 }
+export function isShutdownMessage(data) {
+    return (typeof data === "object" &&
+        data !== null &&
+        "type" in data &&
+        data.type === "__shutdown__");
+}
+export async function handleShutdown(req) {
+    try {
+        // Lazy import to avoid the import cycle:
+        //   handler-utils -> worker-core -> create-server -> handle-request
+        //   -> handler-utils. By the time this runs, all modules are loaded.
+        const { cleanupForTerminate } = await import("../worker-core.js");
+        await cleanupForTerminate();
+        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/cancel-delegated.js

@@ -4,13 +4,12 @@ import { getRPC } from "../../bare/delegate-rpc-client.js";
 import { send } from "../delegate-transport.js";
 const logger = getServerLogger();
 function resolveDelegationTarget(request) {
-    if (request.operation === "inference") {
+    if (request.operation === "inference" || request.operation === "embeddings") {
         const entry = getModelEntry(request.modelId);
-        if (!entry?.isDelegated || !entry.delegated) {
+        if (!entry?.isDelegated) {
             return null;
         }
         const target = {
-            topic: entry.delegated.topic,
             providerPublicKey: entry.delegated.providerPublicKey,
         };
         if (entry.delegated.timeout !== undefined) {
@@ -20,7 +19,6 @@ function resolveDelegationTarget(request) {
     }
     if (request.operation === "downloadAsset" && request.delegate) {
         const target = {
-            topic: request.delegate.topic,
             providerPublicKey: request.delegate.providerPublicKey,
         };
         if (request.delegate.timeout !== undefined) {
@@ -45,7 +43,7 @@ export async function handleCancelDelegated(request, options) {
         return { type: "cancel", success: true };
     }
     try {
-        const rpc = await getRPC(target.topic, target.providerPublicKey, {
+        const rpc = await getRPC(target.providerPublicKey, {
             timeout: target.timeout,
         });
         const delegateOpts = {

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

@@ -1,5 +1,5 @@
 import { cancel } from "../../bare/ops/cancel.js";
-import { createCancelFunction } from "./load-model/download-manager.js";
+import { cancelTransfer } 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();
@@ -7,13 +7,12 @@ export async function cancelHandler(request) {
     try {
         switch (request.operation) {
             case "inference":
+            case "embeddings":
                 await cancel({ modelId: request.modelId });
                 break;
-            case "downloadAsset": {
-                const cancelDownload = createCancelFunction(request.downloadKey, request.clearCache);
-                cancelDownload();
+            case "downloadAsset":
+                cancelTransfer(request.downloadKey, request.clearCache);
                 break;
-            }
             case "rag": {
                 const cancelled = cancelRagOperation(request.workspace);
                 if (!cancelled) {

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

@@ -8,14 +8,13 @@ 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) {
+    if (!entry?.isDelegated) {
         throw new ModelIsDelegatedError(request.modelId);
     }
-    const { topic, providerPublicKey, timeout, healthCheckTimeout } = entry.delegated;
+    const { 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, healthCheckTimeout });
+        const rpc = await getRPC(providerPublicKey, { timeout, healthCheckTimeout });
         // Build delegate options with profiling metadata
         const delegateOpts = { peerKey: providerPublicKey };
         if (profilingMeta) {
@@ -33,10 +32,20 @@ export async function* handleCompletionStreamDelegated(request, options) {
     }
     catch (error) {
         logger.error("Error in delegated completion stream:", error);
+        const message = error instanceof Error ? error.message : String(error);
         yield {
             type: "completionStream",
-            token: `Error communicating with provider: ${error instanceof Error ? error.message : String(error)}`,
             done: true,
+            events: [
+                {
+                    type: "completionDone",
+                    seq: 0,
+                    stopReason: "error",
+                    error: {
+                        message: `Error communicating with provider: ${message}`,
+                    },
+                },
+            ],
         };
     }
 }

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

@@ -1,4 +1,4 @@
-import { deleteCache as deleteCacheUtil } from "../../bare/ops/kv-cache-utils.js";
+import { clearCacheRegistry, deleteCache as deleteCacheUtil, } from "../../bare/ops/kv-cache-utils.js";
 import { clearCachedMessageCounts } from "../../bare/plugins/llamacpp-completion/ops/completion-stream.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
@@ -7,6 +7,7 @@ export async function handleDeleteCache(request) {
         if ("all" in request && request.all) {
             await deleteCacheUtil({ all: true });
             clearCachedMessageCounts();
+            clearCacheRegistry();
         }
         else if ("kvCacheKey" in request) {
             const params = {
@@ -15,8 +16,12 @@ export async function handleDeleteCache(request) {
             if (request.modelId !== undefined) {
                 params.modelId = request.modelId;
             }
-            await deleteCacheUtil(params);
-            clearCachedMessageCounts();
+            const removedPath = await deleteCacheUtil(params);
+            clearCachedMessageCounts(removedPath);
+            clearCacheRegistry({
+                cacheKey: request.kvCacheKey,
+                modelId: request.modelId,
+            });
         }
         return {
             type: "deleteCache",

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

@@ -1,5 +1,6 @@
 import { PROFILING_KEY, OPERATION_EVENT_KEY, } from "../../../schemas/index.js";
 import { resolveModelPath, resolveModelPathWithStats, } from "./load-model/resolve.js";
+import { buildDownloadProfilingFields } from "./load-model/types.js";
 import { nowMs, generateProfileId } from "../../../profiling/clock.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
@@ -27,30 +28,8 @@ export async function handleDownloadAsset(request, progressCallback) {
         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 { gauges, tags } = buildDownloadProfilingFields(downloadStats, sourceType);
+            gauges["totalDownloadTime"] = totalDownloadTimeMs;
             const operationEvent = {
                 op: "downloadAsset",
                 kind: "handler",

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

@@ -0,0 +1,3 @@
+import type { GetLoadedModelInfoRequest, GetLoadedModelInfoResponse } from "../../../schemas/index";
+export declare function handleGetLoadedModelInfo(request: GetLoadedModelInfoRequest): GetLoadedModelInfoResponse;
+//# sourceMappingURL=get-loaded-model-info.d.ts.map

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

@@ -0,0 +1,39 @@
+import { getModelEntry } from "../../bare/registry/model-registry.js";
+import { getPlugin } from "../../plugins/registry.js";
+import { ModelNotFoundError } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
+export function handleGetLoadedModelInfo(request) {
+    const { modelId } = request;
+    const entry = getModelEntry(modelId);
+    if (!entry) {
+        throw new ModelNotFoundError(modelId);
+    }
+    if (entry.isDelegated) {
+        const info = {
+            modelId: entry.id,
+            isDelegated: true,
+            handlers: [],
+            providerInfo: {
+                providerPublicKey: entry.delegated.providerPublicKey,
+            },
+        };
+        return { type: "getLoadedModelInfo", info };
+    }
+    const plugin = getPlugin(entry.local.modelType);
+    if (!plugin) {
+        logger.warn(`getLoadedModelInfo: no plugin registered for modelType "${entry.local.modelType}" on loaded model "${modelId}"`);
+    }
+    const info = {
+        modelId: entry.id,
+        isDelegated: false,
+        modelType: entry.local.modelType,
+        handlers: plugin ? Object.keys(plugin.handlers) : [],
+        loadedAt: entry.local.loadedAt,
+        ...(plugin && { displayName: plugin.displayName }),
+        ...(plugin && { addonPackage: plugin.addonPackage }),
+        ...(entry.local.name && { name: entry.local.name }),
+        ...(entry.local.path && { path: entry.local.path }),
+    };
+    return { type: "getLoadedModelInfo", info };
+}