@qvac/sdk 0.7.1 → 0.8.1

package/dist/client/api/rag.d.ts

@@ -1,4 +1,4 @@
-import type { RagChunkParams, RagDoc, RagIngestParams, RagSaveEmbeddingsParams, RagSaveEmbeddingsResult, RagSearchParams, RagSearchResult, RagDeleteEmbeddingsParams, RagReindexParams, RagReindexResult, RagWorkspaceInfo, RagCloseWorkspaceParams, RagDeleteWorkspaceParams } from "../../schemas/index";
+import type { RagChunkParams, RagDoc, RagIngestParams, RagSaveEmbeddingsParams, RagSaveEmbeddingsResult, RagSearchParams, RagSearchResult, RagDeleteEmbeddingsParams, RagReindexParams, RagReindexResult, RagWorkspaceInfo, RagCloseWorkspaceParams, RagDeleteWorkspaceParams, RPCOptions } from "../../schemas/index";
 /**
  * Chunks documents into smaller pieces for embedding.
  * Part of the segregated flow: ragChunk() → embed() → ragSaveEmbeddings()
@@ -21,7 +21,7 @@ import type { RagChunkParams, RagDoc, RagIngestParams, RagSaveEmbeddingsParams,
  * });
  * ```
  */
-export declare function ragChunk(params: RagChunkParams): Promise<RagDoc[]>;
+export declare function ragChunk(params: RagChunkParams, options?: RPCOptions): Promise<RagDoc[]>;
 /**
  * Ingests documents into the RAG vector database.
  * Full pipeline: chunk → embed → save
@@ -60,7 +60,7 @@ export declare function ragChunk(params: RagChunkParams): Promise<RagDoc[]>;
  * });
  * ```
  */
-export declare function ragIngest(params: RagIngestParams): Promise<{
+export declare function ragIngest(params: RagIngestParams, options?: RPCOptions): Promise<{
     processed: RagSaveEmbeddingsResult[];
     droppedIndices: number[];
 }>;
@@ -96,7 +96,7 @@ export declare function ragIngest(params: RagIngestParams): Promise<{
  * });
  * ```
  */
-export declare function ragSaveEmbeddings(params: RagSaveEmbeddingsParams): Promise<RagSaveEmbeddingsResult[]>;
+export declare function ragSaveEmbeddings(params: RagSaveEmbeddingsParams, options?: RPCOptions): Promise<RagSaveEmbeddingsResult[]>;
 /**
  * Searches for similar documents in the RAG vector database.
  *
@@ -122,7 +122,7 @@ export declare function ragSaveEmbeddings(params: RagSaveEmbeddingsParams): Prom
  * });
  * ```
  */
-export declare function ragSearch(params: RagSearchParams): Promise<RagSearchResult[]>;
+export declare function ragSearch(params: RagSearchParams, options?: RPCOptions): Promise<RagSearchResult[]>;
 /**
  * Deletes document embeddings from the RAG vector database.
  *
@@ -141,7 +141,7 @@ export declare function ragSearch(params: RagSearchParams): Promise<RagSearchRes
  * });
  * ```
  */
-export declare function ragDeleteEmbeddings(params: RagDeleteEmbeddingsParams): Promise<void>;
+export declare function ragDeleteEmbeddings(params: RagDeleteEmbeddingsParams, options?: RPCOptions): Promise<void>;
 /**
  * Reindexes the RAG database to optimize search performance.
  * For HyperDB, this rebalances centroids using k-means clustering.
@@ -180,7 +180,7 @@ export declare function ragDeleteEmbeddings(params: RagDeleteEmbeddingsParams):
  * });
  * ```
  */
-export declare function ragReindex(params: RagReindexParams): Promise<RagReindexResult>;
+export declare function ragReindex(params: RagReindexParams, options?: RPCOptions): Promise<RagReindexResult>;
 /**
  * Lists all RAG workspaces with their open status.
  *
@@ -197,7 +197,7 @@ export declare function ragReindex(params: RagReindexParams): Promise<RagReindex
  * // [{ name: "default", open: true }, { name: "my-docs", open: false }]
  * ```
  */
-export declare function ragListWorkspaces(): Promise<RagWorkspaceInfo[]>;
+export declare function ragListWorkspaces(options?: RPCOptions): Promise<RagWorkspaceInfo[]>;
 /**
  * Closes a RAG workspace, releasing in-memory resources (Corestore, HyperDB adapter, RAG instance).
  *
@@ -219,7 +219,7 @@ export declare function ragListWorkspaces(): Promise<RagWorkspaceInfo[]>;
  * await ragCloseWorkspace({ workspace: "my-docs", deleteOnClose: true });
  * ```
  */
-export declare function ragCloseWorkspace(params?: RagCloseWorkspaceParams): Promise<void>;
+export declare function ragCloseWorkspace(params?: RagCloseWorkspaceParams, options?: RPCOptions): Promise<void>;
 /**
  * Deletes a RAG workspace and all its data.
  * The workspace must not be currently loaded/in-use.
@@ -233,5 +233,5 @@ export declare function ragCloseWorkspace(params?: RagCloseWorkspaceParams): Pro
  * await ragDeleteWorkspace({ workspace: "my-docs" });
  * ```
  */
-export declare function ragDeleteWorkspace(params: RagDeleteWorkspaceParams): Promise<void>;
+export declare function ragDeleteWorkspace(params: RagDeleteWorkspaceParams, options?: RPCOptions): Promise<void>;
 //# sourceMappingURL=rag.d.ts.map

package/dist/client/api/rag.js

@@ -23,13 +23,13 @@ import { InvalidResponseError, InvalidOperationError, StreamEndedError, RAGChunk
  * });
  * ```
  */
-export async function ragChunk(params) {
+export async function ragChunk(params, options) {
     const request = {
         type: "rag",
         operation: "chunk",
         ...params,
     };
-    const response = await send(request);
+    const response = await send(request, options);
     if (response.type !== "rag") {
         throw new InvalidResponseError("rag");
     }
@@ -80,7 +80,7 @@ export async function ragChunk(params) {
  * });
  * ```
  */
-export async function ragIngest(params) {
+export async function ragIngest(params, options) {
     const { onProgress, ...requestParams } = params;
     const request = {
         type: "rag",
@@ -91,7 +91,7 @@ export async function ragIngest(params) {
     };
     if (onProgress) {
         // Use streaming for progress updates
-        for await (const event of stream(request)) {
+        for await (const event of stream(request, options)) {
             if (event.type === "rag:progress" && event.operation === "ingest") {
                 const progress = event;
                 onProgress(progress.stage, progress.current, progress.total);
@@ -109,7 +109,7 @@ export async function ragIngest(params) {
         }
         throw new StreamEndedError();
     }
-    const response = await send(request);
+    const response = await send(request, options);
     if (response.type !== "rag") {
         throw new InvalidResponseError("rag");
     }
@@ -157,7 +157,7 @@ export async function ragIngest(params) {
  * });
  * ```
  */
-export async function ragSaveEmbeddings(params) {
+export async function ragSaveEmbeddings(params, options) {
     const { onProgress, ...requestParams } = params;
     const request = {
         type: "rag",
@@ -166,7 +166,7 @@ export async function ragSaveEmbeddings(params) {
         withProgress: onProgress ? true : undefined,
     };
     if (onProgress) {
-        for await (const event of stream(request)) {
+        for await (const event of stream(request, options)) {
             if (event.type === "rag:progress" &&
                 event.operation === "saveEmbeddings") {
                 const progress = event;
@@ -182,7 +182,7 @@ export async function ragSaveEmbeddings(params) {
         }
         throw new StreamEndedError();
     }
-    const response = await send(request);
+    const response = await send(request, options);
     if (response.type !== "rag") {
         throw new InvalidResponseError("rag");
     }
@@ -220,7 +220,7 @@ export async function ragSaveEmbeddings(params) {
  * });
  * ```
  */
-export async function ragSearch(params) {
+export async function ragSearch(params, options) {
     const request = {
         type: "rag",
         operation: "search",
@@ -228,7 +228,7 @@ export async function ragSearch(params) {
         topK: params.topK ?? 5,
         n: params.n ?? 3,
     };
-    const response = await send(request);
+    const response = await send(request, options);
     if (response.type !== "rag") {
         throw new InvalidResponseError("rag");
     }
@@ -259,13 +259,13 @@ export async function ragSearch(params) {
  * });
  * ```
  */
-export async function ragDeleteEmbeddings(params) {
+export async function ragDeleteEmbeddings(params, options) {
     const request = {
         type: "rag",
         operation: "deleteEmbeddings",
         ...params,
     };
-    const response = await send(request);
+    const response = await send(request, options);
     if (response.type !== "rag") {
         throw new InvalidResponseError("rag");
     }
@@ -315,7 +315,7 @@ export async function ragDeleteEmbeddings(params) {
  * });
  * ```
  */
-export async function ragReindex(params) {
+export async function ragReindex(params, options) {
     const { onProgress, ...requestParams } = params;
     const request = {
         type: "rag",
@@ -324,7 +324,7 @@ export async function ragReindex(params) {
         withProgress: onProgress ? true : undefined,
     };
     if (onProgress) {
-        for await (const event of stream(request)) {
+        for await (const event of stream(request, options)) {
             if (event.type === "rag:progress" && event.operation === "reindex") {
                 const progress = event;
                 onProgress(progress.stage, progress.current, progress.total);
@@ -339,7 +339,7 @@ export async function ragReindex(params) {
         }
         throw new StreamEndedError();
     }
-    const response = await send(request);
+    const response = await send(request, options);
     if (response.type !== "rag") {
         throw new InvalidResponseError("rag");
     }
@@ -368,12 +368,12 @@ export async function ragReindex(params) {
  * // [{ name: "default", open: true }, { name: "my-docs", open: false }]
  * ```
  */
-export async function ragListWorkspaces() {
+export async function ragListWorkspaces(options) {
     const request = {
         type: "rag",
         operation: "listWorkspaces",
     };
-    const response = await send(request);
+    const response = await send(request, options);
     if (response.type !== "rag") {
         throw new InvalidResponseError("rag");
     }
@@ -407,13 +407,13 @@ export async function ragListWorkspaces() {
  * await ragCloseWorkspace({ workspace: "my-docs", deleteOnClose: true });
  * ```
  */
-export async function ragCloseWorkspace(params) {
+export async function ragCloseWorkspace(params, options) {
     const request = {
         type: "rag",
         operation: "closeWorkspace",
         ...params,
     };
-    const response = await send(request);
+    const response = await send(request, options);
     if (response.type !== "rag") {
         throw new InvalidResponseError("rag");
     }
@@ -438,13 +438,13 @@ export async function ragCloseWorkspace(params) {
  * await ragDeleteWorkspace({ workspace: "my-docs" });
  * ```
  */
-export async function ragDeleteWorkspace(params) {
+export async function ragDeleteWorkspace(params, options) {
     const request = {
         type: "rag",
         operation: "deleteWorkspace",
         ...params,
     };
-    const response = await send(request);
+    const response = await send(request, options);
     if (response.type !== "rag") {
         throw new InvalidResponseError("rag");
     }

package/dist/client/api/text-to-speech.d.ts

@@ -1,5 +1,5 @@
-import { type TtsClientParams } from "../../schemas/index";
-export declare function textToSpeech(params: TtsClientParams): {
+import { type TtsClientParams, type RPCOptions } from "../../schemas/index";
+export declare function textToSpeech(params: TtsClientParams, options?: RPCOptions): {
     bufferStream: AsyncGenerator<number>;
     buffer: Promise<number[]>;
     done: Promise<boolean>;

package/dist/client/api/text-to-speech.js

@@ -1,6 +1,6 @@
 import { ttsResponseSchema, } from "../../schemas/index.js";
 import { stream as streamRpc } from "../rpc/rpc-client.js";
-export function textToSpeech(params) {
+export function textToSpeech(params, options) {
     const request = {
         type: "textToSpeech",
         modelId: params.modelId,
@@ -14,7 +14,7 @@ export function textToSpeech(params) {
     });
     if (params.stream) {
         const bufferStream = (async function* () {
-            for await (const response of streamRpc(request)) {
+            for await (const response of streamRpc(request, options)) {
                 if (response.type === "textToSpeech") {
                     const streamResponse = ttsResponseSchema.parse(response);
                     if (streamResponse.buffer.length > 0) {
@@ -38,7 +38,7 @@ export function textToSpeech(params) {
         })();
         const bufferPromise = (async () => {
             let buffer = [];
-            for await (const response of streamRpc(request)) {
+            for await (const response of streamRpc(request, options)) {
                 if (response.type === "textToSpeech") {
                     const streamResponse = ttsResponseSchema.parse(response);
                     buffer = buffer.concat(streamResponse.buffer);

package/dist/client/api/transcribe.d.ts

@@ -1,4 +1,4 @@
-import { type TranscribeClientParams } from "../../schemas/index";
+import { type TranscribeClientParams, type RPCOptions } from "../../schemas/index";
 /**
  * This function streams audio transcription results in real-time, yielding
  * text chunks as they become available from the model.
@@ -7,10 +7,11 @@ import { type TranscribeClientParams } from "../../schemas/index";
  * @param params.modelId - The identifier of the transcription model to use
  * @param params.audioChunk - Audio input as either a file path (string) or audio buffer
  * @param params.prompt - Optional initial prompt to guide the transcription
+ * @param options - Optional RPC options including per-call profiling
  * @yields {string} Text chunks as they are transcribed
  * @throws {QvacErrorBase} When transcription fails with an error message
  */
-export declare function transcribeStream(params: TranscribeClientParams): AsyncGenerator<string, void, unknown>;
+export declare function transcribeStream(params: TranscribeClientParams, options?: RPCOptions): AsyncGenerator<string, void, unknown>;
 /**
  * This function provides a simple interface for transcribing audio by
  * collecting all streaming results into a single string response.
@@ -19,8 +20,9 @@ export declare function transcribeStream(params: TranscribeClientParams): AsyncG
  * @param params.modelId - The identifier of the transcription model to use
  * @param params.audioChunk - Audio input as either a file path (string) or audio buffer
  * @param params.prompt - Optional initial prompt to guide the transcription
+ * @param options - Optional RPC options including per-call profiling
  * @returns {Promise<string>} The complete transcribed text
  * @throws {QvacErrorBase} When transcription fails (propagated from transcribeStream)
  */
-export declare function transcribe(params: TranscribeClientParams): Promise<string>;
+export declare function transcribe(params: TranscribeClientParams, options?: RPCOptions): Promise<string>;
 //# sourceMappingURL=transcribe.d.ts.map

package/dist/client/api/transcribe.js

@@ -8,10 +8,11 @@ import { stream } from "../rpc/rpc-client.js";
  * @param params.modelId - The identifier of the transcription model to use
  * @param params.audioChunk - Audio input as either a file path (string) or audio buffer
  * @param params.prompt - Optional initial prompt to guide the transcription
+ * @param options - Optional RPC options including per-call profiling
  * @yields {string} Text chunks as they are transcribed
  * @throws {QvacErrorBase} When transcription fails with an error message
  */
-export async function* transcribeStream(params) {
+export async function* transcribeStream(params, options) {
     const request = {
         type: "transcribeStream",
         modelId: params.modelId,
@@ -20,7 +21,7 @@ export async function* transcribeStream(params) {
             : { type: "base64", value: params.audioChunk.toString("base64") },
         ...(params.prompt && { prompt: params.prompt }),
     };
-    for await (const response of stream(request)) {
+    for await (const response of stream(request, options)) {
         if (response.type === "transcribeStream") {
             const streamResponse = transcribeStreamResponseSchema.parse(response);
             if (streamResponse.text) {
@@ -40,12 +41,13 @@ export async function* transcribeStream(params) {
  * @param params.modelId - The identifier of the transcription model to use
  * @param params.audioChunk - Audio input as either a file path (string) or audio buffer
  * @param params.prompt - Optional initial prompt to guide the transcription
+ * @param options - Optional RPC options including per-call profiling
  * @returns {Promise<string>} The complete transcribed text
  * @throws {QvacErrorBase} When transcription fails (propagated from transcribeStream)
  */
-export async function transcribe(params) {
+export async function transcribe(params, options) {
     let fullText = "";
-    for await (const textChunk of transcribeStream(params)) {
+    for await (const textChunk of transcribeStream(params, options)) {
         fullText += textChunk;
     }
     return fullText;

package/dist/client/api/translate.d.ts

@@ -1,4 +1,4 @@
-import { type TranslateClientParams, type TranslationStats } from "../../schemas/index";
+import { type TranslateClientParams, type TranslationStats, type RPCOptions } from "../../schemas/index";
 /**
  * Translates text from one language to another using a specified translation model.
  * Supports both NMT (Neural Machine Translation) and LLM models.
@@ -39,7 +39,7 @@ import { type TranslateClientParams, type TranslationStats } from "../../schemas
  * console.log(await response.text);
  * ```
  */
-export declare function translate(params: TranslateClientParams): {
+export declare function translate(params: TranslateClientParams, options?: RPCOptions): {
     tokenStream: AsyncGenerator<string>;
     stats: Promise<TranslationStats | undefined>;
     text: Promise<string>;

package/dist/client/api/translate.js

@@ -42,7 +42,7 @@ import { TranslationFailedError } from "../../utils/errors-client.js";
  * console.log(await response.text);
  * ```
  */
-export function translate(params) {
+export function translate(params, options) {
     const canonicalModelType = normalizeModelType(params.modelType);
     const isLlm = canonicalModelType === ModelType.llamacppCompletion;
     let sourceLanguage = isLlm ? params.from : undefined;
@@ -67,7 +67,7 @@ export function translate(params) {
     });
     if (params.stream) {
         const tokenStream = (async function* () {
-            for await (const response of streamRpc(request)) {
+            for await (const response of streamRpc(request, options)) {
                 if (response.type === "translate") {
                     const streamResponse = translateResponseSchema.parse(response);
                     if (!streamResponse.done) {
@@ -93,7 +93,7 @@ export function translate(params) {
         })();
         const textPromise = (async () => {
             let buffer = "";
-            for await (const response of streamRpc(request)) {
+            for await (const response of streamRpc(request, options)) {
                 if (response.type === "translate") {
                     const streamResponse = translateResponseSchema.parse(response);
                     buffer += streamResponse.token;

package/dist/client/rpc/node-rpc-client.d.ts

@@ -1,9 +1,4 @@
-export declare function getRPC(): {
-    request: (command: number) => {
-        send: (data: string, encoding: BufferEncoding) => void;
-        reply: (encoding: BufferEncoding) => Promise<Buffer>;
-        createResponseStream: () => AsyncGenerator<unknown, void, unknown>;
-    };
-};
+import RPC from "bare-rpc";
+export declare function getRPC(): Promise<RPC>;
 export declare function close(): Promise<void>;
 //# sourceMappingURL=node-rpc-client.d.ts.map

package/dist/client/rpc/node-rpc-client.js

@@ -7,7 +7,6 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { RPCRequestNotSentError } from "../../utils/errors-client.js";
 import { initializeConfig } from "../init-hooks.js";
 import { resolveConfig } from "../config-loader/resolve-config.node.js";
 import { getClientLogger } from "../../logging/index.js";
@@ -202,44 +201,8 @@ async function ensureRPC() {
     await initializeConfig(rpc, resolveConfig, runtimeContext);
     return rpc;
 }
-const mockRPC = {
-    request: (command) => {
-        let sentData = null;
-        return {
-            send: (data, encoding) => {
-                sentData = { data, encoding };
-            },
-            reply: async (encoding) => {
-                if (!sentData) {
-                    throw new RPCRequestNotSentError();
-                }
-                const rpc = await ensureRPC();
-                const req = rpc.request(command);
-                req.send(sentData.data, sentData.encoding);
-                const response = await req.reply(encoding);
-                return Buffer.isBuffer(response)
-                    ? response
-                    : Buffer.from(typeof response === "string" ? response : "", encoding);
-            },
-            createResponseStream: async function* () {
-                if (!sentData) {
-                    throw new RPCRequestNotSentError();
-                }
-                const rpc = await ensureRPC();
-                const req = rpc.request(command);
-                req.send(sentData.data, sentData.encoding);
-                const stream = req.createResponseStream({
-                    encoding: sentData.encoding,
-                });
-                for await (const chunk of stream) {
-                    yield chunk;
-                }
-            },
-        };
-    },
-};
-export function getRPC() {
-    return mockRPC;
+export async function getRPC() {
+    return ensureRPC();
 }
 export async function close() {
     if (closePromise) {

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

@@ -0,0 +1,2 @@
+export * from "./profiler";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+export * from "./profiler.js";

package/dist/client/rpc/profiling/profiler.d.ts

@@ -0,0 +1,27 @@
+import { type BaseTimings } from "../../../profiling/index";
+import type { ProfilingResponseMeta } from "../../../schemas/index";
+interface BaseClientTimings extends BaseTimings {
+    requestZodValidationMs?: number;
+    requestStringifyMs?: number;
+    sendStart?: number;
+    requestEnd?: number;
+}
+export interface ClientTimings extends BaseClientTimings {
+    firstResponseAt?: number;
+    responseJsonParseMs?: number;
+    responseZodValidationMs?: number;
+}
+export interface ClientStreamTimings extends BaseClientTimings {
+    firstChunkAt?: number;
+    lastChunkAt?: number;
+    chunkCount: number;
+}
+export declare function createClientTimings(profileId: string, requestType: string): ClientTimings;
+export declare function createClientStreamTimings(profileId: string, requestType: string): ClientStreamTimings;
+export declare function cacheConnectionTime(durationMs: number): void;
+export declare function flushConnectionTime(): void;
+export declare function recordClientEvents(timings: ClientTimings, serverMeta?: ProfilingResponseMeta): void;
+export declare function recordClientStreamEvents(timings: ClientStreamTimings, serverMeta?: ProfilingResponseMeta): void;
+export declare function resetConnectionTracking(): void;
+export {};
+//# sourceMappingURL=profiler.d.ts.map

package/dist/client/rpc/profiling/profiler.js

@@ -0,0 +1,139 @@
+import { nowMs, record, recordPhase, recordServerBreakdownPhases, recordDelegationBreakdownPhases, } from "../../../profiling/index.js";
+import { getGlobalSingleton } from "../../../utils/global-singleton.js";
+const CONNECTION_TRACKING_STATE_KEY = Symbol.for("@qvac/sdk:rpc-connection-tracking-state");
+function getConnectionTrackingState() {
+    return getGlobalSingleton(CONNECTION_TRACKING_STATE_KEY, () => {
+        return {
+            connectionTimeRecorded: false,
+            pendingConnectionTimeMs: undefined,
+        };
+    });
+}
+function recordRequestPhases(base, timings) {
+    recordPhase(base, "request.zodValidation", timings.requestZodValidationMs);
+    recordPhase(base, "request.stringify", timings.requestStringifyMs);
+    if (timings.requestZodValidationMs !== undefined &&
+        timings.requestStringifyMs !== undefined) {
+        recordPhase(base, "request.totalSerialization", timings.requestZodValidationMs + timings.requestStringifyMs);
+    }
+}
+function createBaseTimings(profileId, requestType) {
+    return { profileId, requestType, requestStart: nowMs() };
+}
+export function createClientTimings(profileId, requestType) {
+    return createBaseTimings(profileId, requestType);
+}
+export function createClientStreamTimings(profileId, requestType) {
+    return { ...createBaseTimings(profileId, requestType), chunkCount: 0 };
+}
+export function cacheConnectionTime(durationMs) {
+    const state = getConnectionTrackingState();
+    if (state.connectionTimeRecorded)
+        return;
+    if (state.pendingConnectionTimeMs !== undefined)
+        return;
+    state.pendingConnectionTimeMs = durationMs;
+}
+export function flushConnectionTime() {
+    const state = getConnectionTrackingState();
+    if (state.connectionTimeRecorded)
+        return;
+    if (state.pendingConnectionTimeMs === undefined)
+        return;
+    const durationMs = state.pendingConnectionTimeMs;
+    state.pendingConnectionTimeMs = undefined;
+    state.connectionTimeRecorded = true;
+    record({
+        ts: nowMs(),
+        op: "rpc",
+        kind: "rpc",
+        phase: "connection",
+        ms: durationMs,
+    });
+}
+export function recordClientEvents(timings, serverMeta) {
+    const now = nowMs();
+    const totalClientTime = now - timings.requestStart;
+    const base = {
+        ts: now,
+        op: timings.requestType,
+        kind: "rpc",
+        profileId: timings.profileId,
+    };
+    recordRequestPhases(base, timings);
+    // For unary requests, this measures send → full response received
+    if (timings.sendStart !== undefined &&
+        timings.firstResponseAt !== undefined) {
+        recordPhase(base, "serverWait", timings.firstResponseAt - timings.sendStart);
+    }
+    recordPhase(base, "response.jsonParse", timings.responseJsonParseMs);
+    recordPhase(base, "response.zodValidation", timings.responseZodValidationMs);
+    if (timings.responseJsonParseMs !== undefined &&
+        timings.responseZodValidationMs !== undefined) {
+        recordPhase(base, "response.totalParsing", timings.responseJsonParseMs + timings.responseZodValidationMs);
+    }
+    recordPhase(base, "totalClientTime", totalClientTime);
+    if (serverMeta?.server) {
+        recordServerBreakdownPhases(base, serverMeta.server, "server");
+        if (serverMeta.server.totalServerMs !== undefined) {
+            recordPhase(base, "clientOverhead", Math.max(0, totalClientTime - serverMeta.server.totalServerMs));
+        }
+    }
+    if (serverMeta?.delegation) {
+        recordDelegationBreakdownPhases(base, serverMeta.delegation);
+    }
+    if (serverMeta?.operation) {
+        recordOperationEvent(serverMeta.operation);
+    }
+}
+function recordOperationEvent(op) {
+    const event = {
+        ts: nowMs(),
+        op: op.op,
+        kind: op.kind,
+        ms: op.ms,
+    };
+    if (op.profileId !== undefined)
+        event.profileId = op.profileId;
+    if (op.gauges !== undefined)
+        event.gauges = op.gauges;
+    if (op.tags !== undefined)
+        event.tags = op.tags;
+    if (op.count !== undefined)
+        event.count = op.count;
+    record(event);
+}
+export function recordClientStreamEvents(timings, serverMeta) {
+    const now = nowMs();
+    const totalClientTime = now - timings.requestStart;
+    const base = {
+        ts: now,
+        op: timings.requestType,
+        kind: "rpc",
+        profileId: timings.profileId,
+    };
+    recordRequestPhases(base, timings);
+    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, "totalClientTime", totalClientTime, {
+        count: timings.chunkCount,
+    });
+    if (serverMeta?.server) {
+        recordServerBreakdownPhases(base, serverMeta.server, "server");
+    }
+    if (serverMeta?.delegation) {
+        recordDelegationBreakdownPhases(base, serverMeta.delegation);
+    }
+    if (serverMeta?.operation) {
+        recordOperationEvent(serverMeta.operation);
+    }
+}
+export function resetConnectionTracking() {
+    const state = getConnectionTrackingState();
+    state.connectionTimeRecorded = false;
+    state.pendingConnectionTimeMs = undefined;
+}

package/dist/client/rpc/rpc-client.d.ts

@@ -1,6 +1,6 @@
 import type RPC from "bare-rpc";
 import { type Request, type Response, type RPCOptions } from "../../schemas/index";
-export declare function send<T extends Request>(request: T, rpc?: RPC, options?: RPCOptions): Promise<Response>;
-export declare function stream<T extends Request>(request: T, rpc?: RPC, options?: RPCOptions): AsyncGenerator<Response>;
+export declare function send<T extends Request>(request: T, options?: RPCOptions, rpc?: RPC): Promise<Response>;
+export declare function stream<T extends Request>(request: T, options?: RPCOptions, rpc?: RPC): AsyncGenerator<Response>;
 export declare function close(): Promise<void>;
 //# sourceMappingURL=rpc-client.d.ts.map