@qvac/sdk 0.7.0 → 0.8.0

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

@@ -1,12 +1,13 @@
-import { modelInputToSrcSchema } from "../../../schemas/index.js";
-import { registerModel } from "../../bare/registry/model-registry.js";
-import { send, stream } from "../delegate-transport.js";
+import { DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, modelInputToSrcSchema } from "../../../schemas/index.js";
+import { registerModel, isModelLoaded, unregisterModel } from "../../bare/registry/model-registry.js";
+import { send, stream, } from "../delegate-transport.js";
 import { getRPC, cleanupStaleConnection, } from "../../bare/delegate-rpc-client.js";
 import { handleLoadModel } from "./load-model/index.js";
 import { ModelLoadFailedError, DelegateNoFinalResponseError, } from "../../../utils/errors-server.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
-export async function handleLoadModelDelegated(request, progressCallback) {
+export async function handleLoadModelDelegated(request, options) {
+    const { progressCallback, profilingMeta } = options ?? {};
     if (!request.delegate) {
         throw new ModelLoadFailedError("Delegate information is required for delegated load model");
     }
@@ -23,10 +24,20 @@ export async function handleLoadModelDelegated(request, progressCallback) {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { delegate: _, ...providerRequest } = request;
         let finalResponse;
+        let delegationBreakdown;
+        let operationEvent;
+        // Build delegate options with profiling metadata
+        const delegateOpts = { peerKey: providerPublicKey };
+        if (profilingMeta) {
+            delegateOpts.profilingMeta = profilingMeta;
+        }
+        if (timeout) {
+            delegateOpts.timeout = timeout;
+        }
         if (request.withProgress) {
             // Use streaming for progress updates
             logger.debug("📊 Using streaming mode for loadModel with progress");
-            const responseStream = stream(providerRequest, rpc, timeout ? { timeout } : {});
+            const responseStream = stream(providerRequest, rpc, delegateOpts);
             for await (const response of responseStream) {
                 if (response.type === "modelProgress") {
                     // Forward progress updates to the client
@@ -36,6 +47,7 @@ export async function handleLoadModelDelegated(request, progressCallback) {
                 }
                 else if (response.type === "loadModel") {
                     finalResponse = response;
+                    operationEvent = response[OPERATION_EVENT_KEY];
                     break;
                 }
             }
@@ -46,7 +58,11 @@ export async function handleLoadModelDelegated(request, progressCallback) {
         else {
             // Use simple send for non-progress requests
             logger.debug("📤 Using simple send mode for loadModel");
-            finalResponse = (await send(providerRequest, rpc, timeout ? { timeout } : {}));
+            const providerResponse = await send(providerRequest, rpc, delegateOpts);
+            finalResponse = providerResponse;
+            const typedResponse = providerResponse;
+            delegationBreakdown = typedResponse[DELEGATION_BREAKDOWN_KEY];
+            operationEvent = typedResponse[OPERATION_EVENT_KEY];
         }
         if (!finalResponse || !finalResponse.success) {
             logger.error("Provider failed to load model:", finalResponse?.error);
@@ -66,13 +82,25 @@ export async function handleLoadModelDelegated(request, progressCallback) {
         if (timeout !== undefined) {
             delegateOptions.timeout = timeout;
         }
+        if (isModelLoaded(modelId)) {
+            logger.info(`Delegated model ${modelId} is already registered, replacing with new provider: ${providerPublicKey}`);
+            unregisterModel(modelId);
+        }
         registerModel(modelId, delegateOptions);
         logger.info(`✅ Delegated model registered: ${modelId} -> provider: ${providerPublicKey}`);
-        return {
+        const result = {
             type: "loadModel",
             success: true,
             modelId,
         };
+        if (delegationBreakdown) {
+            result[DELEGATION_BREAKDOWN_KEY] =
+                delegationBreakdown;
+        }
+        if (operationEvent) {
+            result[OPERATION_EVENT_KEY] = operationEvent;
+        }
+        return result;
     }
     catch (error) {
         logger.error("Error in delegated load model:", error);

package/dist/server/rpc/handlers/plugin-dispatch.js

@@ -1,5 +1,6 @@
 import { getModelEntry } from "../../bare/registry/model-registry.js";
 import { getPlugin } from "../../plugins/index.js";
+import { profileReplyHandler, profileStreamHandler, } from "../profiling/index.js";
 import { ModelNotFoundError, ModelIsDelegatedError, PluginNotFoundError, PluginHandlerNotFoundError, PluginHandlerTypeMismatchError, } from "../../../utils/errors-server.js";
 /**
  * Resolves the plugin handler and returns both the result and streaming flag.
@@ -33,11 +34,13 @@ function resolvePluginHandler(modelId, handlerName, request) {
  * @throws PluginHandlerTypeMismatchError if the handler is streaming
  */
 export async function dispatchPluginReply(modelId, handlerName, request) {
-    const { result, streaming } = resolvePluginHandler(modelId, handlerName, request);
-    if (streaming) {
-        throw new PluginHandlerTypeMismatchError(handlerName, "reply", "streaming");
-    }
-    return result;
+    return profileReplyHandler({ op: handlerName, request }, async () => {
+        const { result, streaming } = resolvePluginHandler(modelId, handlerName, request);
+        if (streaming) {
+            throw new PluginHandlerTypeMismatchError(handlerName, "reply", "streaming");
+        }
+        return result;
+    });
 }
 /**
  * Dispatches a request to a plugin handler and returns an AsyncGenerator.
@@ -46,9 +49,11 @@ export async function dispatchPluginReply(modelId, handlerName, request) {
  * @throws PluginHandlerTypeMismatchError if the handler is not streaming
  */
 export async function* dispatchPluginStream(modelId, handlerName, request) {
-    const { result, streaming } = resolvePluginHandler(modelId, handlerName, request);
-    if (!streaming) {
-        throw new PluginHandlerTypeMismatchError(handlerName, "streaming", "reply");
-    }
-    yield* result;
+    yield* profileStreamHandler({ op: handlerName, request }, async function* () {
+        const { result, streaming } = resolvePluginHandler(modelId, handlerName, request);
+        if (!streaming) {
+            throw new PluginHandlerTypeMismatchError(handlerName, "streaming", "reply");
+        }
+        yield* result;
+    });
 }

package/dist/server/rpc/handlers/plugin-invoke.js

@@ -1,5 +1,6 @@
 import { getModelEntry } from "../../bare/registry/model-registry.js";
 import { getPlugin, getPluginHandler } from "../../plugins/index.js";
+import { profileReplyHandler, profileStreamHandler, } from "../profiling/index.js";
 import { PluginNotFoundError, PluginHandlerNotFoundError, PluginHandlerTypeMismatchError, PluginRequestValidationFailedError, PluginResponseValidationFailedError, ModelIsDelegatedError, ModelNotFoundError, } from "../../../utils/errors-server.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
@@ -24,64 +25,68 @@ function resolvePluginHandler(modelId, handlerName) {
     return { modelType, plugin, handlerDef };
 }
 export async function handlePluginInvoke(request) {
-    const { modelId, handler: handlerName, params } = request;
-    logger.debug(`[pluginInvoke] modelId=${modelId} handler=${handlerName}`);
-    const { handlerDef } = resolvePluginHandler(modelId, handlerName);
-    if (handlerDef.streaming) {
-        throw new PluginHandlerTypeMismatchError(handlerName, "reply", "streaming");
-    }
-    const parseResult = handlerDef.requestSchema.safeParse(params);
-    if (!parseResult.success) {
-        const details = parseResult.error.issues
-            .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-            .join(", ");
-        throw new PluginRequestValidationFailedError(handlerName, details);
-    }
-    const result = await handlerDef.handler(parseResult.data);
-    const responseParseResult = handlerDef.responseSchema.safeParse(result);
-    if (!responseParseResult.success) {
-        const details = responseParseResult.error.issues
-            .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-            .join(", ");
-        throw new PluginResponseValidationFailedError(handlerName, details);
-    }
-    return {
-        type: "pluginInvoke",
-        result: responseParseResult.data,
-    };
-}
-export async function* handlePluginInvokeStream(request) {
-    const { modelId, handler: handlerName, params } = request;
-    logger.debug(`[pluginInvokeStream] modelId=${modelId} handler=${handlerName}`);
-    const { handlerDef } = resolvePluginHandler(modelId, handlerName);
-    if (!handlerDef.streaming) {
-        throw new PluginHandlerTypeMismatchError(handlerName, "streaming", "reply");
-    }
-    const parseResult = handlerDef.requestSchema.safeParse(params);
-    if (!parseResult.success) {
-        const details = parseResult.error.issues
-            .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-            .join(", ");
-        throw new PluginRequestValidationFailedError(handlerName, details);
-    }
-    const generator = handlerDef.handler(parseResult.data);
-    for await (const chunk of generator) {
-        const responseParseResult = handlerDef.responseSchema.safeParse(chunk);
+    return profileReplyHandler({ op: "pluginInvoke", request }, async () => {
+        const { modelId, handler: handlerName, params } = request;
+        logger.debug(`[pluginInvoke] modelId=${modelId} handler=${handlerName}`);
+        const { handlerDef } = resolvePluginHandler(modelId, handlerName);
+        if (handlerDef.streaming) {
+            throw new PluginHandlerTypeMismatchError(handlerName, "reply", "streaming");
+        }
+        const parseResult = handlerDef.requestSchema.safeParse(params);
+        if (!parseResult.success) {
+            const details = parseResult.error.issues
+                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
+                .join(", ");
+            throw new PluginRequestValidationFailedError(handlerName, details);
+        }
+        const result = await handlerDef.handler(parseResult.data);
+        const responseParseResult = handlerDef.responseSchema.safeParse(result);
         if (!responseParseResult.success) {
             const details = responseParseResult.error.issues
                 .map((i) => `${String(i.path.join("."))}: ${i.message}`)
                 .join(", ");
             throw new PluginResponseValidationFailedError(handlerName, details);
         }
+        return {
+            type: "pluginInvoke",
+            result: responseParseResult.data,
+        };
+    });
+}
+export async function* handlePluginInvokeStream(request) {
+    yield* profileStreamHandler({ op: "pluginInvokeStream", request }, async function* () {
+        const { modelId, handler: handlerName, params } = request;
+        logger.debug(`[pluginInvokeStream] modelId=${modelId} handler=${handlerName}`);
+        const { handlerDef } = resolvePluginHandler(modelId, handlerName);
+        if (!handlerDef.streaming) {
+            throw new PluginHandlerTypeMismatchError(handlerName, "streaming", "reply");
+        }
+        const parseResult = handlerDef.requestSchema.safeParse(params);
+        if (!parseResult.success) {
+            const details = parseResult.error.issues
+                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
+                .join(", ");
+            throw new PluginRequestValidationFailedError(handlerName, details);
+        }
+        const generator = handlerDef.handler(parseResult.data);
+        for await (const chunk of generator) {
+            const responseParseResult = handlerDef.responseSchema.safeParse(chunk);
+            if (!responseParseResult.success) {
+                const details = responseParseResult.error.issues
+                    .map((i) => `${String(i.path.join("."))}: ${i.message}`)
+                    .join(", ");
+                throw new PluginResponseValidationFailedError(handlerName, details);
+            }
+            yield {
+                type: "pluginInvokeStream",
+                result: responseParseResult.data,
+                done: false,
+            };
+        }
         yield {
             type: "pluginInvokeStream",
-            result: responseParseResult.data,
-            done: false,
+            result: null,
+            done: true,
         };
-    }
-    yield {
-        type: "pluginInvokeStream",
-        result: null,
-        done: true,
-    };
+    });
 }

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

@@ -1,4 +1,25 @@
 import { chunk, ingest, reindex, saveEmbeddings, search, deleteEmbeddings, listWorkspaces, closeWorkspace, deleteWorkspace, DEFAULT_WORKSPACE, registerRagOperation, unregisterRagOperation, } from "../../bare/rag-hyperdb/index.js";
+import { profileReplyHandler, registerOperationMetrics, } from "../profiling/index.js";
+registerOperationMetrics({
+    op: "rag",
+    kind: "handler",
+    getTags: (req) => {
+        const tags = {};
+        if (req.operation)
+            tags["operation"] = req.operation;
+        if (req.workspace)
+            tags["workspace"] = req.workspace;
+        return tags;
+    },
+    fromResult: (res) => {
+        const gauges = {};
+        if (res.processed !== undefined)
+            gauges["processed"] = res.processed.length;
+        if (res.results !== undefined)
+            gauges["resultsCount"] = res.results.length;
+        return Object.keys(gauges).length > 0 ? gauges : undefined;
+    },
+});
 function createHandlerOptions(operation, workspace, onProgress) {
     const signal = registerRagOperation(workspace, operation);
     const options = { signal };
@@ -22,6 +43,9 @@ function omitOnProgress(obj) {
     return rest;
 }
 export async function handleRag(request, onProgress) {
+    return profileReplyHandler({ op: "rag", request }, async () => handleRagInternal(request, onProgress));
+}
+async function handleRagInternal(request, onProgress) {
     switch (request.operation) {
         case "chunk": {
             const chunks = await chunk(request);

package/dist/server/rpc/handlers/unload-model-delegated.d.ts

@@ -0,0 +1,3 @@
+import type { UnloadModelRequest, UnloadModelResponse } from "../../../schemas/index";
+export declare function handleUnloadModelDelegated(request: UnloadModelRequest): Promise<UnloadModelResponse>;
+//# sourceMappingURL=unload-model-delegated.d.ts.map

package/dist/server/rpc/handlers/unload-model-delegated.js

@@ -0,0 +1,32 @@
+import { getModelEntry, unregisterModel } from "../../bare/registry/model-registry.js";
+import { getRPC } from "../../bare/delegate-rpc-client.js";
+import { send } from "../delegate-transport.js";
+import { hasActiveProviders } from "../../bare/hyperswarm.js";
+import { getRegistryStats } from "../../bare/registry/model-registry.js";
+import { ModelIsDelegatedError } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
+export async function handleUnloadModelDelegated(request) {
+    const entry = getModelEntry(request.modelId);
+    if (!entry?.isDelegated || !entry.delegated) {
+        throw new ModelIsDelegatedError(request.modelId);
+    }
+    const { topic, providerPublicKey, timeout } = entry.delegated;
+    unregisterModel(request.modelId);
+    try {
+        logger.info(`Sending delegated unload for model ${request.modelId} to provider: ${providerPublicKey}`);
+        const rpc = await getRPC(topic, providerPublicKey, { timeout });
+        await send({ type: "unloadModel", modelId: request.modelId, clearStorage: false }, rpc, { timeout });
+        logger.info(`Delegated model ${request.modelId} unloaded on provider`);
+    }
+    catch (error) {
+        logger.error(`Failed to unload delegated model ${request.modelId} on provider:`, error);
+    }
+    const stats = getRegistryStats();
+    return {
+        type: "unloadModel",
+        success: true,
+        hasActiveModels: stats.totalModels > 0,
+        hasActiveProviders: hasActiveProviders(),
+    };
+}

package/dist/server/rpc/profiling/context.d.ts

@@ -0,0 +1,18 @@
+import { type ProfilingRequestMeta, type DelegationBreakdown, type OperationEvent } from "../../../schemas/index";
+export interface ServerProfilingContext {
+    meta: ProfilingRequestMeta;
+    requestStart: number;
+    jsonParseMs?: number;
+    zodValidationMs?: number;
+    handlerExecutionMs?: number;
+    responseZodValidationMs?: number;
+    responseStringifyMs?: number;
+}
+export declare function createProfilingContext(meta: ProfilingRequestMeta): ServerProfilingContext;
+export interface ProfilingInjectionOptions {
+    ctx?: ServerProfilingContext;
+    delegation?: DelegationBreakdown;
+    operation?: OperationEvent;
+}
+export declare function injectProfilingIntoString(jsonString: string, options: ProfilingInjectionOptions): string;
+//# sourceMappingURL=context.d.ts.map

package/dist/server/rpc/profiling/context.js

@@ -0,0 +1,38 @@
+import { PROFILING_KEY, } from "../../../schemas/index.js";
+import { nowMs } from "../../../profiling/index.js";
+export function createProfilingContext(meta) {
+    return { meta, requestStart: nowMs() };
+}
+function buildServerBreakdown(ctx) {
+    return {
+        requestJsonParseMs: ctx.jsonParseMs,
+        requestZodValidationMs: ctx.zodValidationMs,
+        handlerExecutionMs: ctx.handlerExecutionMs,
+        responseZodValidationMs: ctx.responseZodValidationMs,
+        responseStringifyMs: ctx.responseStringifyMs,
+        totalServerMs: nowMs() - ctx.requestStart,
+    };
+}
+export function injectProfilingIntoString(jsonString, options) {
+    const { ctx, delegation, operation } = options;
+    const includeServer = ctx?.meta.includeServer ?? false;
+    const hasContent = includeServer || !!delegation || !!operation;
+    if (!hasContent || !jsonString.endsWith("}")) {
+        return jsonString;
+    }
+    const id = ctx?.meta.id ?? delegation?.profileId ?? operation?.profileId ?? "";
+    const profilingMeta = { id };
+    if (includeServer && ctx) {
+        profilingMeta["server"] = buildServerBreakdown(ctx);
+    }
+    if (delegation) {
+        const { profileId: _unused, ...delegationWithoutId } = delegation;
+        void _unused;
+        profilingMeta["delegation"] = delegationWithoutId;
+    }
+    if (operation) {
+        profilingMeta["operation"] = operation;
+    }
+    return (jsonString.slice(0, -1) +
+        `,"${PROFILING_KEY}":${JSON.stringify(profilingMeta)}}`);
+}

package/dist/server/rpc/profiling/delegation-profiler.d.ts

@@ -0,0 +1,32 @@
+import { type BaseTimings } from "../../../profiling/index";
+import type { ProfilingRequestMeta, ProfilingResponseMeta, DelegationBreakdown } from "../../../schemas/index";
+export interface DelegatedHandlerOptions {
+    profilingMeta?: ProfilingRequestMeta;
+}
+interface BaseDelegationTimings extends BaseTimings {
+    requestStringifyMs?: number;
+    sendStart?: number;
+}
+export interface DelegationTimings extends BaseDelegationTimings {
+    firstResponseAt?: number;
+    responseJsonParseMs?: number;
+}
+export interface DelegationStreamTimings extends BaseDelegationTimings {
+    firstChunkAt?: number;
+    lastChunkAt?: number;
+    chunkCount: number;
+}
+export declare function shouldProfileDelegation(op: string, incomingMeta?: ProfilingRequestMeta): boolean;
+export declare function createDelegationTimings(profileId: string, requestType: string): DelegationTimings;
+export declare function createDelegationStreamTimings(profileId: string, requestType: string): DelegationStreamTimings;
+export declare function cacheDelegationConnectionTime(peerKey: string, durationMs: number): void;
+export declare function flushServerConnectionEvent(peerKey: string): void;
+export declare function consumeBreakdownConnectionTime(peerKey: string): number | undefined;
+export declare function buildDelegationBreakdown(timings: DelegationTimings, connectionMs?: number): DelegationBreakdown;
+export declare function buildDelegationStreamBreakdown(timings: DelegationStreamTimings): DelegationBreakdown;
+export declare function recordDelegationEvents(timings: DelegationTimings, serverMeta?: ProfilingResponseMeta, connectionMs?: number): DelegationBreakdown;
+export declare function recordDelegationStreamEvents(timings: DelegationStreamTimings, serverMeta?: ProfilingResponseMeta): void;
+export declare function clearPeerConnectionTracking(peerKey: string): void;
+export declare function resetDelegationConnectionTracking(): void;
+export {};
+//# sourceMappingURL=delegation-profiler.d.ts.map

package/dist/server/rpc/profiling/delegation-profiler.js

@@ -0,0 +1,154 @@
+import { nowMs, record, shouldProfile, recordPhase, recordServerBreakdownPhases, } from "../../../profiling/index.js";
+/**
+ * Per-peer connection tracking for delegation.
+ * Separate tracking for server-side event recording vs breakdown injection.
+ *
+ * Flow:
+ * 1. Connection happens → cacheDelegationConnectionTime stores ms
+ * 2. First profiled call (stream or unary) → flushServerConnectionEvent records server event
+ * 3. First unary call → consumeBreakdownConnectionTime returns ms for breakdown injection
+ */
+const pendingConnectionTimes = new Map();
+const serverConnectionRecorded = new Map();
+const breakdownConnectionMs = new Map();
+const breakdownConnectionInjected = new Map();
+export function shouldProfileDelegation(op, incomingMeta) {
+    if (incomingMeta?.enabled === false) {
+        return false;
+    }
+    if (incomingMeta?.enabled === true) {
+        return true;
+    }
+    return shouldProfile(op);
+}
+export function createDelegationTimings(profileId, requestType) {
+    return { profileId, requestType, requestStart: nowMs() };
+}
+export function createDelegationStreamTimings(profileId, requestType) {
+    return { profileId, requestType, requestStart: nowMs(), chunkCount: 0 };
+}
+export function cacheDelegationConnectionTime(peerKey, durationMs) {
+    if (serverConnectionRecorded.get(peerKey))
+        return;
+    if (pendingConnectionTimes.has(peerKey))
+        return;
+    pendingConnectionTimes.set(peerKey, durationMs);
+}
+export function flushServerConnectionEvent(peerKey) {
+    if (serverConnectionRecorded.get(peerKey))
+        return;
+    const ms = pendingConnectionTimes.get(peerKey);
+    if (ms === undefined)
+        return;
+    pendingConnectionTimes.delete(peerKey);
+    serverConnectionRecorded.set(peerKey, true);
+    if (!breakdownConnectionInjected.get(peerKey)) {
+        breakdownConnectionMs.set(peerKey, ms);
+    }
+    record({
+        ts: nowMs(),
+        op: "delegation",
+        kind: "delegation",
+        phase: "connection",
+        ms,
+        tags: { peer: peerKey.slice(0, 16) },
+    });
+}
+export function consumeBreakdownConnectionTime(peerKey) {
+    if (breakdownConnectionInjected.get(peerKey))
+        return undefined;
+    const ms = breakdownConnectionMs.get(peerKey);
+    if (ms === undefined)
+        return undefined;
+    breakdownConnectionMs.delete(peerKey);
+    breakdownConnectionInjected.set(peerKey, true);
+    return ms;
+}
+export function buildDelegationBreakdown(timings, connectionMs) {
+    const now = nowMs();
+    const breakdown = {
+        profileId: timings.profileId,
+    };
+    if (connectionMs !== undefined) {
+        breakdown.connectionMs = connectionMs;
+    }
+    if (timings.requestStringifyMs !== undefined) {
+        breakdown.requestStringifyMs = timings.requestStringifyMs;
+    }
+    if (timings.sendStart !== undefined &&
+        timings.firstResponseAt !== undefined) {
+        breakdown.serverWaitMs = timings.firstResponseAt - timings.sendStart;
+    }
+    if (timings.responseJsonParseMs !== undefined) {
+        breakdown.responseJsonParseMs = timings.responseJsonParseMs;
+    }
+    breakdown.totalDelegationMs = now - timings.requestStart;
+    return breakdown;
+}
+export function buildDelegationStreamBreakdown(timings) {
+    const now = nowMs();
+    const breakdown = {
+        profileId: timings.profileId,
+    };
+    if (timings.requestStringifyMs !== undefined) {
+        breakdown.requestStringifyMs = timings.requestStringifyMs;
+    }
+    if (timings.sendStart !== undefined && timings.firstChunkAt !== undefined) {
+        breakdown.serverWaitMs = timings.firstChunkAt - timings.sendStart;
+    }
+    breakdown.totalDelegationMs = now - timings.requestStart;
+    return breakdown;
+}
+export function recordDelegationEvents(timings, serverMeta, connectionMs) {
+    const now = nowMs();
+    const base = {
+        ts: now,
+        op: timings.requestType,
+        kind: "delegation",
+        profileId: timings.profileId,
+    };
+    const breakdown = buildDelegationBreakdown(timings, connectionMs);
+    recordPhase(base, "request.stringify", breakdown.requestStringifyMs);
+    recordPhase(base, "serverWait", breakdown.serverWaitMs);
+    recordPhase(base, "response.jsonParse", breakdown.responseJsonParseMs);
+    recordPhase(base, "totalDelegationTime", breakdown.totalDelegationMs);
+    if (serverMeta?.server) {
+        recordServerBreakdownPhases(base, serverMeta.server, "delegated");
+    }
+    return breakdown;
+}
+export function recordDelegationStreamEvents(timings, serverMeta) {
+    const now = nowMs();
+    const totalTime = now - timings.requestStart;
+    const base = {
+        ts: now,
+        op: timings.requestType,
+        kind: "delegation",
+        profileId: timings.profileId,
+    };
+    recordPhase(base, "request.stringify", timings.requestStringifyMs);
+    if (timings.sendStart !== undefined && timings.firstChunkAt !== undefined) {
+        recordPhase(base, "ttfb", timings.firstChunkAt - timings.sendStart);
+    }
+    if (timings.firstChunkAt !== undefined && timings.lastChunkAt !== undefined) {
+        recordPhase(base, "streamDuration", timings.lastChunkAt - timings.firstChunkAt);
+    }
+    recordPhase(base, "totalDelegationTime", totalTime, {
+        count: timings.chunkCount,
+    });
+    if (serverMeta?.server) {
+        recordServerBreakdownPhases(base, serverMeta.server, "delegated");
+    }
+}
+export function clearPeerConnectionTracking(peerKey) {
+    pendingConnectionTimes.delete(peerKey);
+    serverConnectionRecorded.delete(peerKey);
+    breakdownConnectionMs.delete(peerKey);
+    breakdownConnectionInjected.delete(peerKey);
+}
+export function resetDelegationConnectionTracking() {
+    pendingConnectionTimes.clear();
+    serverConnectionRecorded.clear();
+    breakdownConnectionMs.clear();
+    breakdownConnectionInjected.clear();
+}

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

@@ -0,0 +1,5 @@
+export { createServerProfiler, type ServerProfiler } from "./profiler";
+export { profileReplyHandler, profileStreamHandler, } from "./operation-wrappers";
+export { registerOperationMetrics, buildOperationEvent, type OperationMetricsConfig, } from "./operation-metrics";
+export { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, cacheDelegationConnectionTime, flushServerConnectionEvent, consumeBreakdownConnectionTime, clearPeerConnectionTracking, resetDelegationConnectionTracking, type DelegationTimings, type DelegationStreamTimings, type DelegatedHandlerOptions, } from "./delegation-profiler";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,4 @@
+export { createServerProfiler } from "./profiler.js";
+export { profileReplyHandler, profileStreamHandler, } from "./operation-wrappers.js";
+export { registerOperationMetrics, buildOperationEvent, } from "./operation-metrics.js";
+export { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, cacheDelegationConnectionTime, flushServerConnectionEvent, consumeBreakdownConnectionTime, clearPeerConnectionTracking, resetDelegationConnectionTracking, } from "./delegation-profiler.js";

package/dist/server/rpc/profiling/operation-metrics.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Declarative extraction of operation-level metrics from request/response data.
+ * Used by operation wrappers to capture handler-specific profiling events.
+ */
+import type { ProfilingEvent, ProfilingEventKind } from "../../../profiling/types";
+import type { DownloadStats } from "../handlers/load-model/types";
+export type MetricExtractor<T> = (data: T) => Record<string, number> | undefined;
+export type TagExtractor<T> = (data: T) => Record<string, string> | undefined;
+export interface OperationMetricsConfig<TRequest = unknown, TResponse = unknown> {
+    op: string;
+    kind: ProfilingEventKind;
+    fromRequest?: MetricExtractor<TRequest>;
+    fromFinalChunk?: MetricExtractor<TResponse>;
+    fromResult?: MetricExtractor<TResponse>;
+    getTags?: (request: TRequest) => Record<string, string>;
+    getTagsFromResult?: TagExtractor<TResponse>;
+}
+export interface DownloadAssetProfilingMeta {
+    sourceType?: string;
+    downloadStats?: DownloadStats;
+    totalDownloadTimeMs?: number;
+}
+export declare function registerOperationMetrics<TRequest, TResponse>(config: OperationMetricsConfig<TRequest, TResponse>): void;
+export declare function buildOperationEvent(op: string, profileId: string, ts: number, executionMs: number, request?: unknown, finalResponse?: unknown, ttfb?: number): ProfilingEvent | undefined;
+//# sourceMappingURL=operation-metrics.d.ts.map