@qvac/sdk 0.8.0 → 0.8.2

package/dist/server/bare/delegate-rpc-client.js

@@ -12,6 +12,26 @@ const activeRPCs = new Map();
 const activeConnections = new Map();
 // Track whether the global connection handler has been registered
 let connectionHandlerRegistered = false;
+const HEALTH_CHECK_TIMEOUT_MS = 1500;
+import { getNextCommandId } from "../rpc/delegate-utils.js";
+function isHeartbeatResponse(payload) {
+    return (typeof payload === "object" &&
+        payload !== null &&
+        payload["type"] === "heartbeat");
+}
+async function isRPCConnectionHealthy(rpc, timeout = HEALTH_CHECK_TIMEOUT_MS) {
+    try {
+        const req = rpc.request(getNextCommandId());
+        req.send(JSON.stringify({ type: "heartbeat" }), "utf-8");
+        const response = await withTimeout(req.reply("utf-8"), timeout);
+        const payload = JSON.parse(response?.toString() || "{}");
+        return isHeartbeatResponse(payload);
+    }
+    catch (error) {
+        logger.debug("RPC health check failed", { error });
+        return false;
+    }
+}
 /**
  * Register the swarm "connection" handler once (not per getRPC call).
  * This fixes the event listener leak where each getRPC() call added
@@ -68,11 +88,28 @@ async function closeConnection(publicKey) {
     }
 }
 // Establish RPC connection to a peer if not already connected
-async function ensureRPCConnection(topic, publicKey, timeout) {
+async function ensureRPCConnection(topic, publicKey, timeout, healthCheckTimeout) {
+    const healthCheckCap = healthCheckTimeout ?? HEALTH_CHECK_TIMEOUT_MS;
+    const operationStart = nowMs();
+    const getRemainingTimeout = () => {
+        if (timeout === undefined) {
+            return undefined;
+        }
+        return Math.max(timeout - (nowMs() - operationStart), 0);
+    };
     // Check if we already have an RPC instance for this peer
     const existingRpc = activeRPCs.get(publicKey);
     if (existingRpc) {
-        return existingRpc;
+        const remainingTimeout = getRemainingTimeout();
+        const probeTimeout = remainingTimeout === undefined
+            ? healthCheckCap
+            : Math.min(remainingTimeout / 2, healthCheckCap);
+        const isHealthy = await isRPCConnectionHealthy(existingRpc, probeTimeout);
+        if (isHealthy) {
+            return existingRpc;
+        }
+        logger.info(`🧹 Cached RPC failed health check for peer ${publicKey}, reconnecting`);
+        cleanupStaleConnection(publicKey);
     }
     const swarm = getSwarm();
     const connectionStart = nowMs();
@@ -132,7 +169,7 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
                 logger.debug(`⏳ Peer not connected after flush, waiting for connection event...`);
             });
         });
-        const rpc = await withTimeout(connectionPromise, timeout);
+        const rpc = await withTimeout(connectionPromise, getRemainingTimeout());
         const connectionDuration = nowMs() - connectionStart;
         cacheDelegationConnectionTime(publicKey, connectionDuration);
         return rpc;
@@ -142,13 +179,7 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
         swarm.removeListener("connection", onConnection);
         // Remove stale connection so next attempt creates a fresh one
         // instead of reusing a dead RPC
-        logger.info(`🗑️ Removing stale connection for peer: ${publicKey} after failed RPC attempt`);
-        activeRPCs.delete(publicKey);
-        const conn = activeConnections.get(publicKey);
-        if (conn) {
-            conn.destroy();
-            activeConnections.delete(publicKey);
-        }
+        cleanupStaleConnection(publicKey);
         logger.error("Failed to establish RPC connection:", error);
         throw new DelegateConnectionFailedError(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`, error);
     }
@@ -162,7 +193,7 @@ export async function getRPC(topic, publicKey, options = {}) {
     if (options.forceNewConnection) {
         await closeConnection(publicKey);
     }
-    return await ensureRPCConnection(topic, publicKey, options.timeout);
+    return await ensureRPCConnection(topic, publicKey, options.timeout, options.healthCheckTimeout);
 }
 /**
  * Remove a stale RPC connection for a peer.

package/dist/server/bare/plugins/nmtcpp-translation/plugin.js

@@ -4,7 +4,7 @@ import { definePlugin, defineHandler, translateRequestSchema, translateResponseS
 import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
 import FilesystemDL from "@qvac/dl-filesystem";
-import { TranslationFailedError, ModelLoadFailedError, } from "../../../../utils/errors-server.js";
+import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
 import { asLoader } from "../../utils/loader-adapter.js";
 import { translate } from "../../ops/translate.js";
 const BERGAMOT_CJK_LANG_PAIRS = ["enja", "enko", "enzh"];
@@ -90,9 +90,6 @@ function createNmtModel(modelId, modelPath, nmtConfig, srcVocabPath, dstVocabPat
             }),
         }),
     };
-    if (config.modelType === TranslationNmtcpp.ModelTypes.IndicTrans) {
-        throw new TranslationFailedError("IndicTrans models are not supported with current NMT addon version.");
-    }
     const model = new TranslationNmtcpp(args, config);
     return { model, loader };
 }

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

@@ -12,6 +12,7 @@ interface DelegateOptions {
     topic: string;
     providerPublicKey: string;
     timeout?: number | undefined;
+    healthCheckTimeout?: number | undefined;
 }
 interface LocalOptions {
     model: AnyModel;
@@ -39,6 +40,7 @@ export declare function registerModel(id: string, options: {
     topic: string;
     providerPublicKey: string;
     timeout?: number;
+    healthCheckTimeout?: number;
 }): void;
 export declare function getModelEntry(id: string): ModelEntry | null;
 export declare function getModel(id: string): AnyModel;

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

@@ -9,7 +9,7 @@ export function registerModel(id, options) {
     }
     const isDelegated = "topic" in options && "providerPublicKey" in options;
     if (isDelegated) {
-        const { topic, providerPublicKey, timeout } = options;
+        const { topic, providerPublicKey, timeout, healthCheckTimeout } = options;
         modelRegistry.set(id, {
             id,
             isDelegated: true,
@@ -17,6 +17,7 @@ export function registerModel(id, options) {
                 topic,
                 providerPublicKey,
                 timeout,
+                healthCheckTimeout,
             },
         });
         logger.info(`Delegated model registered: ${id} -> topic: ${topic}, provider: ${providerPublicKey}, timeout: ${timeout}ms`);

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

@@ -9,18 +9,25 @@ import { nowMs, extractProfilingMeta, recordFailure, generateId, } from "../../p
 import { withTimeout, withTimeoutStream } from "../../utils/withTimeout.js";
 import { getServerLogger } from "../../logging/index.js";
 import { DelegateProviderError } from "../../utils/errors-server.js";
+import { cleanupStaleConnection } from "../bare/delegate-rpc-client.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;
-}
+import { getNextCommandId } from "./delegate-utils.js";
 function checkAndThrowError(response) {
     if (response.type === "error") {
         throw new DelegateProviderError(response.message || "Unknown provider error", response.code);
     }
 }
+function isConnectionError(error) {
+    return !(error instanceof DelegateProviderError);
+}
+function cleanupDelegationPeer(options, error) {
+    if (!options?.peerKey)
+        return;
+    if (error !== undefined && !isConnectionError(error))
+        return;
+    cleanupStaleConnection(options.peerKey);
+}
 export async function send(request, rpc, options) {
     const { profilingMeta } = options ?? {};
     const shouldProfile = shouldProfileDelegation(request.type, profilingMeta);
@@ -30,20 +37,26 @@ export async function send(request, rpc, options) {
     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;
+    try {
+        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;
+    }
+    catch (error) {
+        cleanupDelegationPeer(options, error);
+        throw error;
+    }
 }
 async function sendProfiled(request, rpc, options, profilingMeta) {
     const profileId = profilingMeta?.id ?? generateId();
@@ -93,6 +106,7 @@ async function sendProfiled(request, rpc, options, profilingMeta) {
         return resPayload;
     }
     catch (error) {
+        cleanupDelegationPeer(options, error);
         const base = {
             ts: nowMs(),
             op: timings.requestType,
@@ -113,35 +127,41 @@ export async function* stream(request, rpc, options = {}) {
     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;
+    try {
+        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;
+        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;
+                }
             }
         }
     }
+    catch (error) {
+        cleanupDelegationPeer(options, error);
+        throw error;
+    }
 }
 async function* streamProfiled(request, rpc, options = {}, profilingMeta) {
     const profileId = profilingMeta?.id ?? generateId();
@@ -203,6 +223,7 @@ async function* streamProfiled(request, rpc, options = {}, profilingMeta) {
         recordDelegationStreamEvents(timings, lastServerMeta);
     }
     catch (error) {
+        cleanupDelegationPeer(options, error);
         const base = {
             ts: nowMs(),
             op: timings.requestType,

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

@@ -0,0 +1,2 @@
+export declare function getNextCommandId(): number;
+//# sourceMappingURL=delegate-utils.d.ts.map

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

@@ -0,0 +1,5 @@
+let commandCounter = 0;
+export function getNextCommandId() {
+    commandCounter = (commandCounter + 1) % Number.MAX_SAFE_INTEGER;
+    return commandCounter;
+}

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

@@ -19,7 +19,9 @@ 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 { handleHeartbeat } from "./handlers/heartbeat.js";
+import { handleHeartbeatDelegated } from "./handlers/heartbeat-delegated.js";
+import { handleCancelDelegated } from "./handlers/cancel-delegated.js";
 import { handlePluginInvoke, handlePluginInvokeStream, } from "./handlers/plugin-invoke.js";
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./handlers/registry.js";
 function ragSupportsProgress(request) {
@@ -33,9 +35,25 @@ function isModelDelegated(request) {
     const entry = getModelEntry(request.modelId);
     return entry?.isDelegated ?? false;
 }
+function isCancelDelegated(request) {
+    if (request.type !== "cancel")
+        return false;
+    if (request.operation === "inference") {
+        return isModelDelegated(request);
+    }
+    if (request.operation === "downloadAsset") {
+        return !!request.delegate;
+    }
+    return false;
+}
 export const registry = {
     // Simple Reply handlers
-    ping: { type: "reply", handler: handlePing },
+    heartbeat: {
+        type: "reply",
+        handler: handleHeartbeat,
+        delegatedHandler: handleHeartbeatDelegated,
+        isDelegated: (r) => r.type === "heartbeat" && !!r.delegate,
+    },
     unloadModel: {
         type: "reply",
         handler: handleUnloadModel,
@@ -43,7 +61,12 @@ export const registry = {
         isDelegated: isModelDelegated,
     },
     embed: { type: "reply", handler: handleEmbed },
-    cancel: { type: "reply", handler: cancelHandler },
+    cancel: {
+        type: "reply",
+        handler: cancelHandler,
+        delegatedHandler: handleCancelDelegated,
+        isDelegated: isCancelDelegated,
+    },
     provide: { type: "reply", handler: provideHandler },
     stopProvide: { type: "reply", handler: stopProvideHandler },
     deleteCache: { type: "reply", handler: handleDeleteCache },

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

@@ -3,6 +3,7 @@ import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.j
 import { setSDKConfig } from "../bare/registry/config-registry.js";
 import { setRuntimeContext } from "../bare/registry/runtime-context-registry.js";
 import {} from "./profiling/index.js";
+import { nowMs } from "../../profiling/clock.js";
 function getProfilingMetaFromRequest(request) {
     if (PROFILING_KEY in request) {
         return request[PROFILING_KEY];
@@ -56,12 +57,37 @@ async function executeStreamHandler(req, request, handler, profiler, isDelegated
         sendStreamErrorResponse(stream, error, profiler);
     }
 }
+const PROGRESS_THROTTLE_MS = 150;
 async function executeProgressHandler(req, request, handler, profiler, isDelegated) {
     const stream = req.createResponseStream();
     profiler.startHandler();
-    const progressCallback = (update) => {
+    let lastProgressWrite = 0;
+    let pendingUpdate = null;
+    let flushTimer = null;
+    const writeProgress = (update) => {
         stream.write(profiler.serialize(update, false) + "\n", "utf-8");
     };
+    const progressCallback = (update) => {
+        const now = nowMs();
+        if (now - lastProgressWrite >= PROGRESS_THROTTLE_MS) {
+            lastProgressWrite = now;
+            pendingUpdate = null;
+            writeProgress(update);
+        }
+        else {
+            pendingUpdate = update;
+            if (!flushTimer) {
+                flushTimer = setTimeout(() => {
+                    flushTimer = null;
+                    if (pendingUpdate) {
+                        lastProgressWrite = nowMs();
+                        writeProgress(pendingUpdate);
+                        pendingUpdate = null;
+                    }
+                }, PROGRESS_THROTTLE_MS - (now - lastProgressWrite));
+            }
+        }
+    };
     try {
         let response;
         if (isDelegated) {
@@ -75,11 +101,27 @@ async function executeProgressHandler(req, request, handler, profiler, isDelegat
         else {
             response = await handler(request, progressCallback);
         }
+        if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+        }
+        if (pendingUpdate) {
+            writeProgress(pendingUpdate);
+            pendingUpdate = null;
+        }
         profiler.endHandler();
         stream.write(profiler.serialize(response, true) + "\n", "utf-8");
         stream.end();
     }
     catch (error) {
+        if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+        }
+        if (pendingUpdate) {
+            writeProgress(pendingUpdate);
+            pendingUpdate = null;
+        }
         profiler.endHandler();
         sendStreamErrorResponse(stream, error, profiler);
     }

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

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

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.js

@@ -11,11 +11,11 @@ export async function* handleCompletionStreamDelegated(request, options) {
     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) {

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,