@qvac/sdk 0.7.1 → 0.8.1

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

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

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/handle-request.js

@@ -1,32 +1,71 @@
-import { requestSchema, normalizeModelType, } from "../../schemas/index.js";
+import { requestSchema, normalizeModelType, PROFILING_KEY, } from "../../schemas/index.js";
+import { nowMs } from "../../profiling/index.js";
 import { resolveModelConfig } from "../bare/registry/model-config-registry.js";
 import { sendErrorResponse } from "../error-handlers.js";
 import { RPCNoDataReceivedError, RPCUnknownRequestTypeError, } from "../../utils/errors-server.js";
 import { registry } from "./handler-registry.js";
 import { executeHandler, handleInitConfig, isInitConfigMessage, } from "./handler-utils.js";
+import { createServerProfiler } from "./profiling/index.js";
 export async function handleRequest(req) {
+    let profiler;
+    let validationStart = 0;
     try {
         const rawData = req.data?.toString();
         if (!rawData) {
             throw new RPCNoDataReceivedError();
         }
+        // Timing runs unconditionally since we can't know if client
+        // requested profiling until after parsing.
+        const parseStart = nowMs();
         const jsonData = JSON.parse(rawData);
+        const jsonParseMs = nowMs() - parseStart;
         // Handle internal config initialization (bypasses schema)
         if (isInitConfigMessage(jsonData)) {
             handleInitConfig(req, jsonData);
             return;
         }
-        const processedData = applyDeviceDefaultsToRequest(jsonData);
+        const { data: cleanData, profilingMeta } = extractProfilingMeta(jsonData);
+        profiler = createServerProfiler(profilingMeta);
+        profiler.markRequestParsed(jsonParseMs);
+        validationStart = nowMs();
+        const processedData = applyDeviceDefaultsToRequest(cleanData);
         const request = requestSchema.parse(processedData);
+        attachProfilingMetaToRequest(request, profilingMeta);
+        profiler.markRequestValidated(nowMs() - validationStart);
+        validationStart = 0;
         const entry = registry[request.type];
         if (!entry) {
             throw new RPCUnknownRequestTypeError(request.type);
         }
-        await executeHandler(req, request, entry);
+        await executeHandler(req, request, entry, profiler);
     }
     catch (error) {
-        sendErrorResponse(req, error);
+        if (profiler && validationStart > 0) {
+            profiler.markRequestValidated(nowMs() - validationStart);
+        }
+        sendErrorResponse(req, error, profiler);
+    }
+}
+function attachProfilingMetaToRequest(request, profilingMeta) {
+    if (!profilingMeta)
+        return;
+    Object.defineProperty(request, PROFILING_KEY, {
+        value: profilingMeta,
+        enumerable: false,
+        configurable: true,
+        writable: false,
+    });
+}
+function extractProfilingMeta(data) {
+    if (!data || typeof data !== "object" || !(PROFILING_KEY in data)) {
+        return { data, profilingMeta: undefined };
     }
+    const obj = data;
+    const { [PROFILING_KEY]: meta, ...rest } = obj;
+    return {
+        data: rest,
+        profilingMeta: meta,
+    };
 }
 /**
  * Apply device-specific config defaults to loadModel requests before schema parsing.

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

@@ -6,6 +6,7 @@ import { handleLoadModelDelegated } from "./handlers/load-model-delegated.js";
 import { handleCompletionStreamDelegated } from "./handlers/completion-stream-delegated.js";
 import { getModelEntry } from "../bare/registry/model-registry.js";
 import { handleUnloadModel } from "./handlers/unload-model.js";
+import { handleUnloadModelDelegated } from "./handlers/unload-model-delegated.js";
 import { handleTranscribeStream } from "./handlers/transcribe-stream.js";
 import { handleEmbed } from "./handlers/embed.js";
 import { handleTranslate } from "./handlers/translate.js";
@@ -18,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) {
@@ -32,12 +35,38 @@ 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 },
-    unloadModel: { type: "reply", handler: handleUnloadModel },
+    heartbeat: {
+        type: "reply",
+        handler: handleHeartbeat,
+        delegatedHandler: handleHeartbeatDelegated,
+        isDelegated: (r) => r.type === "heartbeat" && !!r.delegate,
+    },
+    unloadModel: {
+        type: "reply",
+        handler: handleUnloadModel,
+        delegatedHandler: handleUnloadModelDelegated,
+        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.d.ts

@@ -1,8 +1,9 @@
 import { type QvacConfig, type Request, type Response, type RuntimeContext } from "../../schemas/index";
 import type RPC from "bare-rpc";
-type ReplyHandler = (request: any) => Promise<Response> | Response;
-type StreamHandler = (request: any) => AsyncGenerator<Response>;
-type ProgressHandler = (request: any, onProgress?: (update: Response) => void) => Promise<Response>;
+import { type ServerProfiler } from "./profiling/index";
+type ReplyHandler = (request: any, ...args: any[]) => Promise<Response> | Response;
+type StreamHandler = (request: any, ...args: any[]) => AsyncGenerator<Response>;
+type ProgressHandler = (request: any, ...args: any[]) => Promise<Response>;
 export type HandlerEntry = {
     type: "reply" | "stream";
     handler: ReplyHandler | StreamHandler | ProgressHandler;
@@ -10,7 +11,7 @@ export type HandlerEntry = {
     isDelegated?: (request: Request) => boolean;
     supportsProgress?: boolean | ((request: Request) => boolean);
 };
-export declare function executeHandler(req: RPC.IncomingRequest, request: Request, entry: HandlerEntry): Promise<void>;
+export declare function executeHandler(req: RPC.IncomingRequest, request: Request, entry: HandlerEntry, profiler: ServerProfiler): Promise<void>;
 type InitConfigMessage = {
     type: "__init_config";
     config: QvacConfig;

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

@@ -1,65 +1,148 @@
-import { responseSchema, } from "../../schemas/index.js";
+import { PROFILING_KEY, } from "../../schemas/index.js";
 import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
 import { setSDKConfig } from "../bare/registry/config-registry.js";
 import { setRuntimeContext } from "../bare/registry/runtime-context-registry.js";
-function writeToStream(stream, response) {
-    stream.write(JSON.stringify(responseSchema.parse(response)) + "\n", "utf-8");
+import {} from "./profiling/index.js";
+import { nowMs } from "../../profiling/clock.js";
+function getProfilingMetaFromRequest(request) {
+    if (PROFILING_KEY in request) {
+        return request[PROFILING_KEY];
+    }
+    return undefined;
 }
-async function executeReplyHandler(req, request, handler) {
+async function executeReplyHandler(req, request, handler, profiler, isDelegated) {
+    profiler.startHandler();
     try {
-        const response = await handler(request);
-        req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+        let response;
+        if (isDelegated) {
+            const profilingMeta = getProfilingMetaFromRequest(request);
+            response = await handler(request, profilingMeta ? { profilingMeta } : undefined);
+        }
+        else {
+            response = await handler(request);
+        }
+        profiler.endHandler();
+        req.reply(profiler.serialize(response, true), "utf-8");
     }
     catch (error) {
-        sendErrorResponse(req, error);
+        profiler.endHandler();
+        sendErrorResponse(req, error, profiler);
     }
 }
-async function executeStreamHandler(req, request, handler) {
+async function executeStreamHandler(req, request, handler, profiler, isDelegated) {
     const stream = req.createResponseStream();
+    profiler.startHandler();
     try {
-        for await (const response of handler(request)) {
-            stream.write(JSON.stringify(responseSchema.parse(response)) + "\n", "utf-8");
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let generator;
+        if (isDelegated) {
+            const profilingMeta = getProfilingMetaFromRequest(request);
+            generator = handler(request, profilingMeta ? { profilingMeta } : undefined);
+        }
+        else {
+            generator = handler(request);
+        }
+        for await (const response of generator) {
+            stream.write(profiler.serialize(response, false) + "\n", "utf-8");
+        }
+        profiler.endHandler();
+        const trailer = profiler.serialize();
+        if (trailer) {
+            stream.write(trailer + "\n", "utf-8");
         }
         stream.end();
     }
     catch (error) {
-        sendStreamErrorResponse(stream, error);
+        profiler.endHandler();
+        sendStreamErrorResponse(stream, error, profiler);
     }
 }
-async function executeProgressHandler(req, request, handler) {
+const PROGRESS_THROTTLE_MS = 150;
+async function executeProgressHandler(req, request, handler, profiler, isDelegated) {
     const stream = req.createResponseStream();
+    profiler.startHandler();
+    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 {
-        const response = await handler(request, (update) => writeToStream(stream, update));
-        writeToStream(stream, response);
+        let response;
+        if (isDelegated) {
+            const profilingMeta = getProfilingMetaFromRequest(request);
+            const options = { progressCallback };
+            if (profilingMeta) {
+                options.profilingMeta = profilingMeta;
+            }
+            response = await handler(request, options);
+        }
+        else {
+            response = await handler(request, progressCallback);
+        }
+        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) {
-        sendStreamErrorResponse(stream, error);
+        if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+        }
+        if (pendingUpdate) {
+            writeProgress(pendingUpdate);
+            pendingUpdate = null;
+        }
+        profiler.endHandler();
+        sendStreamErrorResponse(stream, error, profiler);
     }
 }
 // Unified handler executor with delegation and progress support
-export async function executeHandler(req, request, entry) {
-    const handler = entry.delegatedHandler && entry.isDelegated?.(request)
-        ? entry.delegatedHandler
-        : entry.handler;
+export async function executeHandler(req, request, entry, profiler) {
+    const isDelegated = !!(entry.delegatedHandler && entry.isDelegated?.(request));
+    const handler = isDelegated ? entry.delegatedHandler : entry.handler;
     const wantsProgress = "withProgress" in request &&
         request.withProgress &&
         (typeof entry.supportsProgress === "function"
             ? entry.supportsProgress(request)
             : entry.supportsProgress);
-    try {
-        if (entry.type === "stream") {
-            await executeStreamHandler(req, request, handler);
-        }
-        else if (wantsProgress) {
-            await executeProgressHandler(req, request, handler);
-        }
-        else {
-            await executeReplyHandler(req, request, handler);
-        }
+    if (entry.type === "stream") {
+        await executeStreamHandler(req, request, handler, profiler, isDelegated);
     }
-    catch (error) {
-        sendErrorResponse(req, error);
+    else if (wantsProgress) {
+        await executeProgressHandler(req, request, handler, profiler, isDelegated);
+    }
+    else {
+        await executeReplyHandler(req, request, handler, profiler, isDelegated);
     }
 }
 export function isInitConfigMessage(data) {

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