@qvac/sdk 0.7.0 → 0.8.0

package/dist/client/api/invoke-plugin.js

@@ -3,14 +3,14 @@ import { InvalidResponseError } from "../../utils/errors-client.js";
 /**
  * Invoke a non-streaming plugin handler.
  */
-export async function invokePlugin(options) {
+export async function invokePlugin(options, rpcOptions) {
     const request = {
         type: "pluginInvoke",
         modelId: options.modelId,
         handler: options.handler,
         params: options.params,
     };
-    const response = await send(request);
+    const response = await send(request, rpcOptions);
     if (response.type !== "pluginInvoke") {
         throw new InvalidResponseError("pluginInvoke");
     }
@@ -19,14 +19,14 @@ export async function invokePlugin(options) {
 /**
  * Invoke a streaming plugin handler.
  */
-export async function* invokePluginStream(options) {
+export async function* invokePluginStream(options, rpcOptions) {
     const request = {
         type: "pluginInvokeStream",
         modelId: options.modelId,
         handler: options.handler,
         params: options.params,
     };
-    for await (const chunk of stream(request)) {
+    for await (const chunk of stream(request, rpcOptions)) {
         const response = chunk;
         if (response.type !== "pluginInvokeStream") {
             throw new InvalidResponseError("pluginInvokeStream");

package/dist/client/api/load-model.d.ts

@@ -1,4 +1,4 @@
-import { type LoadModelOptions, type ReloadConfigOptions } from "../../schemas/index";
+import { type LoadModelOptions, type ReloadConfigOptions, type RPCOptions } from "../../schemas/index";
 /**
  * Loads a machine learning model from a local path, remote URL, or Hyperdrive key.
  *
@@ -11,11 +11,10 @@ import { type LoadModelOptions, type ReloadConfigOptions } from "../../schemas/i
  * @param options - An object that defines all configuration parameters required for loading the model, including:
  *   - modelSrc: The location from which the model weights are fetched (local path, remote URL, or Hyperdrive URL)
  *   - modelType: The type of model ("llm", "whisper", "embeddings", "nmt", or "tts")
- *   - modelConfig: Model-specific configuration options
- *   - projectionModelSrc: (LLM only) Projection model source for multimodal models
- *   - vadModelSrc: (Whisper only) VAD model source for voice activity detection
+ *   - modelConfig: Model-specific configuration options (companion sources, model parameters, etc.)
  *   - onProgress: Callback for download progress updates
  *   - logger: Logger instance for model operation logs
+ * @param rpcOptions - Optional RPC options including per-call profiling configuration
  *
  * @returns Promise that resolves to the model ID (either the provided modelSrc or a generated ID)
  *
@@ -58,8 +57,10 @@ import { type LoadModelOptions, type ReloadConfigOptions } from "../../schemas/i
  * const multimodalId = await loadModel({
  *   modelSrc: "https://huggingface.co/.../main-model.gguf",
  *   modelType: "llm",
- *   projectionModelSrc: "https://huggingface.co/.../projection-model.gguf",
- *   modelConfig: { ctx_size: 512 },
+ *   modelConfig: {
+ *     ctx_size: 512,
+ *     projectionModelSrc: "https://huggingface.co/.../projection-model.gguf"
+ *   },
  *   onProgress: (progress) => {
  *     console.log(`Loading: ${progress.percentage}%`);
  *   }
@@ -69,12 +70,12 @@ import { type LoadModelOptions, type ReloadConfigOptions } from "../../schemas/i
  * const whisperId = await loadModel({
  *   modelSrc: "https://huggingface.co/.../whisper-model.gguf",
  *   modelType: "whisper",
- *   vadModelSrc: "https://huggingface.co/.../vad-model.bin",
  *   modelConfig: {
  *     mode: "caption",
  *     output_format: "plaintext",
  *     min_seconds: 2,
- *     max_seconds: 6
+ *     max_seconds: 6,
+ *     vadModelSrc: "https://huggingface.co/.../vad-model.bin"
  *   }
  * });
  *
@@ -89,7 +90,7 @@ import { type LoadModelOptions, type ReloadConfigOptions } from "../../schemas/i
  * });
  * ```
  */
-export declare function loadModel(options: LoadModelOptions): Promise<string>;
+export declare function loadModel(options: LoadModelOptions, rpcOptions?: RPCOptions): Promise<string>;
 /**
  * Hot-reloads configuration on an already loaded model.
  *
@@ -97,6 +98,7 @@ export declare function loadModel(options: LoadModelOptions): Promise<string>;
  *   - modelId: The ID of an existing loaded model
  *   - modelType: The type of model (must match the loaded model)
  *   - modelConfig: New configuration to apply
+ * @param rpcOptions - Optional RPC options including per-call profiling configuration
  *
  * @returns Promise that resolves to the model ID
  *
@@ -120,5 +122,5 @@ export declare function loadModel(options: LoadModelOptions): Promise<string>;
  * });
  * ```
  */
-export declare function loadModel(options: ReloadConfigOptions): Promise<string>;
+export declare function loadModel(options: ReloadConfigOptions, rpcOptions?: RPCOptions): Promise<string>;
 //# sourceMappingURL=load-model.d.ts.map

package/dist/client/api/load-model.js

@@ -4,7 +4,7 @@ import { loadModelOptionsToRequestSchema, reloadConfigOptionsToRequestSchema, is
 import { ModelLoadFailedError, StreamEndedError, InvalidResponseError, } from "../../utils/errors-client.js";
 import { getClientLogger } from "../../logging/index.js";
 const logger = getClientLogger();
-export async function loadModel(options) {
+export async function loadModel(options, rpcOptions) {
     const isReloadConfig = "modelId" in options && !("modelSrc" in options);
     // Warn about deprecated alias usage
     if (!isReloadConfig && isModelTypeAlias(options.modelType)) {
@@ -18,7 +18,7 @@ export async function loadModel(options) {
     const onProgress = isReloadConfig ? undefined : options.onProgress;
     if (onProgress) {
         // Use streaming for progress updates
-        for await (const response of stream(request)) {
+        for await (const response of stream(request, rpcOptions)) {
             if (response.type === "modelProgress") {
                 onProgress(response);
             }
@@ -42,7 +42,7 @@ export async function loadModel(options) {
         throw new StreamEndedError();
     }
     // Use regular send for simple loading
-    const response = await send(request);
+    const response = await send(request, rpcOptions);
     if (response.type !== "loadModel") {
         throw new InvalidResponseError("loadModel");
     }

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