@qvac/sdk 0.7.1 → 0.8.0

package/dist/server/bare/plugins/whispercpp-transcription/plugin.d.ts

@@ -1,8 +1,214 @@
-import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type WhisperConfig } from "../../../../schemas/index";
 export declare const whisperPlugin: {
     modelType: "whispercpp-transcription";
     displayName: string;
-    addonPackage: string;
+    addonPackage: "@qvac/transcription-whispercpp";
+    loadConfigSchema: import("zod").ZodObject<{
+        strategy: import("zod").ZodOptional<import("zod").ZodEnum<{
+            greedy: "greedy";
+            beam_search: "beam_search";
+        }>>;
+        n_threads: import("zod").ZodOptional<import("zod").ZodNumber>;
+        n_max_text_ctx: import("zod").ZodOptional<import("zod").ZodNumber>;
+        offset_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+        duration_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+        audio_ctx: import("zod").ZodOptional<import("zod").ZodNumber>;
+        translate: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        no_context: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        no_timestamps: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        single_segment: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        print_special: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        print_progress: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        print_realtime: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        print_timestamps: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        token_timestamps: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        thold_pt: import("zod").ZodOptional<import("zod").ZodNumber>;
+        thold_ptsum: import("zod").ZodOptional<import("zod").ZodNumber>;
+        max_len: import("zod").ZodOptional<import("zod").ZodNumber>;
+        split_on_word: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        max_tokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+        debug_mode: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        tdrz_enable: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        suppress_regex: import("zod").ZodOptional<import("zod").ZodString>;
+        initial_prompt: import("zod").ZodOptional<import("zod").ZodString>;
+        language: import("zod").ZodOptional<import("zod").ZodString>;
+        detect_language: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        suppress_blank: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        suppress_nst: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+        length_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+        temperature_inc: import("zod").ZodOptional<import("zod").ZodNumber>;
+        entropy_thold: import("zod").ZodOptional<import("zod").ZodNumber>;
+        logprob_thold: import("zod").ZodOptional<import("zod").ZodNumber>;
+        greedy_best_of: import("zod").ZodOptional<import("zod").ZodNumber>;
+        beam_search_beam_size: import("zod").ZodOptional<import("zod").ZodNumber>;
+        vad_params: import("zod").ZodOptional<import("zod").ZodObject<{
+            threshold: import("zod").ZodOptional<import("zod").ZodNumber>;
+            min_speech_duration_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+            min_silence_duration_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+            max_speech_duration_s: import("zod").ZodOptional<import("zod").ZodNumber>;
+            speech_pad_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+            samples_overlap: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+        audio_format: import("zod").ZodOptional<import("zod").ZodEnum<{
+            f32le: "f32le";
+            s16le: "s16le";
+        }>>;
+        contextParams: import("zod").ZodOptional<import("zod").ZodObject<{
+            model: import("zod").ZodOptional<import("zod").ZodString>;
+            use_gpu: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            flash_attn: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            gpu_device: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+        miscConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+            caption_enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+        vadModelSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+            src: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            modelId: import("zod").ZodOptional<import("zod").ZodString>;
+            registryPath: import("zod").ZodOptional<import("zod").ZodString>;
+            registrySource: import("zod").ZodOptional<import("zod").ZodString>;
+            blobCoreKey: import("zod").ZodOptional<import("zod").ZodString>;
+            blobIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
+            engine: import("zod").ZodOptional<import("zod").ZodString>;
+            expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+            sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
+            addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                "llamacpp-completion": "llamacpp-completion";
+                "whispercpp-transcription": "whispercpp-transcription";
+                "llamacpp-embedding": "llamacpp-embedding";
+                "nmtcpp-translation": "nmtcpp-translation";
+                "onnx-tts": "onnx-tts";
+                "parakeet-transcription": "parakeet-transcription";
+                "onnx-ocr": "onnx-ocr";
+                llm: "llm";
+                whisper: "whisper";
+                embeddings: "embeddings";
+                nmt: "nmt";
+                parakeet: "parakeet";
+                tts: "tts";
+                ocr: "ocr";
+            }>, import("zod").ZodLiteral<"vad">]>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>;
+    resolveConfig(cfg: WhisperConfig, ctx: ResolveContext): Promise<{
+        config: {
+            strategy?: "greedy" | "beam_search" | undefined;
+            n_threads?: number | undefined;
+            n_max_text_ctx?: number | undefined;
+            offset_ms?: number | undefined;
+            duration_ms?: number | undefined;
+            audio_ctx?: number | undefined;
+            translate?: boolean | undefined;
+            no_context?: boolean | undefined;
+            no_timestamps?: boolean | undefined;
+            single_segment?: boolean | undefined;
+            print_special?: boolean | undefined;
+            print_progress?: boolean | undefined;
+            print_realtime?: boolean | undefined;
+            print_timestamps?: boolean | undefined;
+            token_timestamps?: boolean | undefined;
+            thold_pt?: number | undefined;
+            thold_ptsum?: number | undefined;
+            max_len?: number | undefined;
+            split_on_word?: boolean | undefined;
+            max_tokens?: number | undefined;
+            debug_mode?: boolean | undefined;
+            tdrz_enable?: boolean | undefined;
+            suppress_regex?: string | undefined;
+            initial_prompt?: string | undefined;
+            language?: string | undefined;
+            detect_language?: boolean | undefined;
+            suppress_blank?: boolean | undefined;
+            suppress_nst?: boolean | undefined;
+            temperature?: number | undefined;
+            length_penalty?: number | undefined;
+            temperature_inc?: number | undefined;
+            entropy_thold?: number | undefined;
+            logprob_thold?: number | undefined;
+            greedy_best_of?: number | undefined;
+            beam_search_beam_size?: number | undefined;
+            vad_params?: {
+                threshold?: number | undefined;
+                min_speech_duration_ms?: number | undefined;
+                min_silence_duration_ms?: number | undefined;
+                max_speech_duration_s?: number | undefined;
+                speech_pad_ms?: number | undefined;
+                samples_overlap?: number | undefined;
+            } | undefined;
+            audio_format?: "f32le" | "s16le" | undefined;
+            contextParams?: {
+                model?: string | undefined;
+                use_gpu?: boolean | undefined;
+                flash_attn?: boolean | undefined;
+                gpu_device?: number | undefined;
+            } | undefined;
+            miscConfig?: {
+                caption_enabled?: boolean | undefined;
+            } | undefined;
+        };
+        artifacts?: never;
+    } | {
+        config: {
+            strategy?: "greedy" | "beam_search" | undefined;
+            n_threads?: number | undefined;
+            n_max_text_ctx?: number | undefined;
+            offset_ms?: number | undefined;
+            duration_ms?: number | undefined;
+            audio_ctx?: number | undefined;
+            translate?: boolean | undefined;
+            no_context?: boolean | undefined;
+            no_timestamps?: boolean | undefined;
+            single_segment?: boolean | undefined;
+            print_special?: boolean | undefined;
+            print_progress?: boolean | undefined;
+            print_realtime?: boolean | undefined;
+            print_timestamps?: boolean | undefined;
+            token_timestamps?: boolean | undefined;
+            thold_pt?: number | undefined;
+            thold_ptsum?: number | undefined;
+            max_len?: number | undefined;
+            split_on_word?: boolean | undefined;
+            max_tokens?: number | undefined;
+            debug_mode?: boolean | undefined;
+            tdrz_enable?: boolean | undefined;
+            suppress_regex?: string | undefined;
+            initial_prompt?: string | undefined;
+            language?: string | undefined;
+            detect_language?: boolean | undefined;
+            suppress_blank?: boolean | undefined;
+            suppress_nst?: boolean | undefined;
+            temperature?: number | undefined;
+            length_penalty?: number | undefined;
+            temperature_inc?: number | undefined;
+            entropy_thold?: number | undefined;
+            logprob_thold?: number | undefined;
+            greedy_best_of?: number | undefined;
+            beam_search_beam_size?: number | undefined;
+            vad_params?: {
+                threshold?: number | undefined;
+                min_speech_duration_ms?: number | undefined;
+                min_silence_duration_ms?: number | undefined;
+                max_speech_duration_s?: number | undefined;
+                speech_pad_ms?: number | undefined;
+                samples_overlap?: number | undefined;
+            } | undefined;
+            audio_format?: "f32le" | "s16le" | undefined;
+            contextParams?: {
+                model?: string | undefined;
+                use_gpu?: boolean | undefined;
+                flash_attn?: boolean | undefined;
+                gpu_device?: number | undefined;
+            } | undefined;
+            miscConfig?: {
+                caption_enabled?: boolean | undefined;
+            } | undefined;
+        };
+        artifacts: {
+            vadModelPath: string;
+        };
+    }>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
         transcribeStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
@@ -25,7 +231,7 @@ export declare const whisperPlugin: {
     };
     logging: {
         module: import("@qvac/transcription-whispercpp/addonLogging").AddonLogging;
-        namespace: "whispercpp";
+        namespace: "whispercpp-transcription";
     };
 };
 //# sourceMappingURL=plugin.d.ts.map

package/dist/server/bare/plugins/whispercpp-transcription/plugin.js

@@ -1,20 +1,20 @@
 import whisperAddonLogging from "@qvac/transcription-whispercpp/addonLogging.js";
 import TranscriptionWhispercpp, {} from "@qvac/transcription-whispercpp";
-import { definePlugin, defineHandler, transcribeStreamRequestSchema, transcribeStreamResponseSchema, ModelType, } from "../../../../schemas/index.js";
-import { ADDON_NAMESPACES, createStreamLogger } from "../../../../logging/index.js";
+import { definePlugin, defineHandler, transcribeStreamRequestSchema, transcribeStreamResponseSchema, ModelType, whisperConfigSchema, ADDON_WHISPER, } from "../../../../schemas/index.js";
+import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
 import FilesystemDL from "@qvac/dl-filesystem";
-import { transcribe } from "./ops/transcribe-stream.js";
+import { transcribe } from "../../ops/transcribe.js";
 function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
     const { dirPath, basePath } = parseModelPath(modelPath);
     let vadModelName = "";
-    const effectiveVadPath = vadModelPath || whisperConfig.vad_model_path;
-    if (effectiveVadPath) {
-        const vadParsed = parseModelPath(effectiveVadPath);
+    if (vadModelPath) {
+        const vadParsed = parseModelPath(vadModelPath);
         vadModelName = vadParsed.basePath;
     }
     const loader = new FilesystemDL({ dirPath });
-    const logger = createStreamLogger(modelId, "whispercpp");
+    const logger = createStreamLogger(modelId, ModelType.whispercppTranscription);
+    registerAddonLogger(modelId, ModelType.whispercppTranscription, logger);
     const args = {
         loader,
         logger,
@@ -37,7 +37,19 @@ function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
 export const whisperPlugin = definePlugin({
     modelType: ModelType.whispercppTranscription,
     displayName: "Whisper (whisper.cpp)",
-    addonPackage: "@qvac/transcription-whispercpp",
+    addonPackage: ADDON_WHISPER,
+    loadConfigSchema: whisperConfigSchema,
+    async resolveConfig(cfg, ctx) {
+        const { vadModelSrc, ...whisperConfig } = cfg;
+        if (!vadModelSrc) {
+            return { config: whisperConfig };
+        }
+        const vadModelPath = await ctx.resolveModelPath(vadModelSrc);
+        return {
+            config: whisperConfig,
+            artifacts: { vadModelPath },
+        };
+    },
     createModel(params) {
         const whisperConfig = (params.modelConfig ?? {});
         const { model, loader } = createWhisperModel(params.modelId, params.modelPath, whisperConfig, params.artifacts?.["vadModelPath"]);
@@ -69,6 +81,6 @@ export const whisperPlugin = definePlugin({
     },
     logging: {
         module: whisperAddonLogging,
-        namespace: ADDON_NAMESPACES.WHISPERCPP,
+        namespace: ModelType.whispercppTranscription,
     },
 });

package/dist/server/bare/rag-hyperdb/rag-workspace-manager.js

@@ -5,7 +5,7 @@ import path from "bare-path";
 import { getConfiguredCacheDir } from "../registry/config-registry.js";
 import { RAGWorkspaceModelMismatchError, RAGWorkspaceNotOpenError, } from "../../../utils/errors-server.js";
 import { validateAndJoinPath } from "../../utils/path-security.js";
-import { createStreamLogger, getServerLogger, ADDON_NAMESPACES, } from "../../../logging/index.js";
+import { createStreamLogger, getServerLogger, RAG_NAMESPACE, } from "../../../logging/index.js";
 import { cancelAllRagOperations } from "./rag-operation-manager.js";
 const logger = getServerLogger();
 const ragWorkspaces = new Map();
@@ -59,7 +59,7 @@ export async function getRagInstance(modelId, embeddingFunction, workspace) {
         }
         return entry.rag;
     }
-    const workspaceLogger = createStreamLogger(key, ADDON_NAMESPACES.RAG_HYPERDB);
+    const workspaceLogger = createStreamLogger(key, RAG_NAMESPACE);
     const rag = new RAG({
         dbAdapter: entry.dbAdapter,
         embeddingFunction,

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

@@ -1,11 +1,12 @@
 import { ModelType, } from "../../../schemas/index.js";
 import { llmConfigSchema, embedConfigSchema } from "../../../schemas/llamacpp-config.js";
-import { whisperConfigSchema } from "../../../schemas/whispercpp-config.js";
+import { whisperConfigSchema, parakeetRuntimeConfigSchema, } from "../../../schemas/transcription-config.js";
 import { ocrConfigSchema } from "../../../schemas/ocr.js";
 export const CANONICAL_TO_ALIAS = {
     [ModelType.llamacppCompletion]: "llm",
     [ModelType.llamacppEmbedding]: "embeddings",
     [ModelType.whispercppTranscription]: "whisper",
+    [ModelType.parakeetTranscription]: "parakeet",
     [ModelType.nmtcppTranslation]: "nmt",
     [ModelType.onnxTts]: "tts",
     [ModelType.onnxOcr]: "ocr",
@@ -14,6 +15,7 @@ export const MODEL_CONFIG_SCHEMAS = {
     [ModelType.llamacppCompletion]: llmConfigSchema,
     [ModelType.llamacppEmbedding]: embedConfigSchema,
     [ModelType.whispercppTranscription]: whisperConfigSchema,
+    [ModelType.parakeetTranscription]: parakeetRuntimeConfigSchema.passthrough(),
     [ModelType.onnxOcr]: ocrConfigSchema,
 };
 // Ordered general → specific (later patterns override earlier)

package/dist/server/bare/utils/audio-input.d.ts

@@ -0,0 +1,10 @@
+import { Readable } from "bare-stream";
+import type { AudioInput, AudioFormat } from "../../../schemas/index";
+/**
+ * Converts an AudioInput (base64 or filePath) into a Readable stream,
+ * decoding the audio when necessary.
+ *
+ * Shared by all transcription plugins (Whisper, Parakeet, etc.).
+ */
+export declare function createAudioStream(audioChunk: AudioInput, audioFormat: AudioFormat): Promise<Readable>;
+//# sourceMappingURL=audio-input.d.ts.map

package/dist/server/bare/utils/audio-input.js

@@ -0,0 +1,33 @@
+import { Readable } from "bare-stream";
+import fs from "bare-fs";
+import { needsDecoding, decodeAudioToStream, } from "../../utils/audio/decoder.js";
+import { AudioFileNotFoundError, InvalidAudioChunkError, } from "../../../utils/errors-server.js";
+/**
+ * Converts an AudioInput (base64 or filePath) into a Readable stream,
+ * decoding the audio when necessary.
+ *
+ * Shared by all transcription plugins (Whisper, Parakeet, etc.).
+ */
+export async function createAudioStream(audioChunk, audioFormat) {
+    switch (audioChunk.type) {
+        case "base64": {
+            const audioBuffer = Buffer.from(audioChunk.value, "base64");
+            return Readable.from([audioBuffer]);
+        }
+        case "filePath": {
+            const filePath = audioChunk.value;
+            try {
+                fs.accessSync(filePath);
+            }
+            catch (error) {
+                throw new AudioFileNotFoundError(filePath, error);
+            }
+            if (needsDecoding(filePath)) {
+                return decodeAudioToStream(filePath, audioFormat);
+            }
+            return fs.createReadStream(filePath);
+        }
+        default:
+            throw new InvalidAudioChunkError();
+    }
+}

package/dist/server/error-handlers.d.ts

@@ -1,4 +1,5 @@
 import type RPC from "bare-rpc";
-export declare function sendErrorResponse(req: RPC.IncomingRequest, error: unknown): void;
-export declare function sendStreamErrorResponse(stream: ReturnType<RPC.IncomingRequest["createResponseStream"]>, error: unknown): void;
+import { type ServerProfiler } from "./rpc/profiling/index";
+export declare function sendErrorResponse(req: RPC.IncomingRequest, error: unknown, profiler?: ServerProfiler): void;
+export declare function sendStreamErrorResponse(stream: ReturnType<RPC.IncomingRequest["createResponseStream"]>, error: unknown, profiler?: ServerProfiler): void;
 //# sourceMappingURL=error-handlers.d.ts.map

package/dist/server/error-handlers.js

@@ -1,11 +1,16 @@
 import { createErrorResponse, responseSchema } from "../schemas/index.js";
 import { getServerLogger } from "../logging/index.js";
+import {} from "./rpc/profiling/index.js";
 const logger = getServerLogger();
-export function sendErrorResponse(req, error) {
+function buildErrorResponseData(error, profiler) {
+    const errorResponse = createErrorResponse(error);
+    const validated = responseSchema.parse(errorResponse);
+    const json = JSON.stringify(validated);
+    return profiler ? profiler.serializeError(json) : json;
+}
+export function sendErrorResponse(req, error, profiler) {
     try {
-        const errorResponse = createErrorResponse(error);
-        const responseData = JSON.stringify(responseSchema.parse(errorResponse));
-        req.reply(responseData, "utf-8");
+        req.reply(buildErrorResponseData(error, profiler), "utf-8");
     }
     catch (responseError) {
         logger.error("Failed to create error response:", responseError);
@@ -13,11 +18,9 @@ export function sendErrorResponse(req, error) {
         req.reply(JSON.stringify(fallbackError), "utf-8");
     }
 }
-export function sendStreamErrorResponse(stream, error) {
+export function sendStreamErrorResponse(stream, error, profiler) {
     try {
-        const errorResponse = createErrorResponse(error);
-        const responseData = JSON.stringify(responseSchema.parse(errorResponse));
-        stream.write(responseData + "\n", "utf-8");
+        stream.write(buildErrorResponseData(error, profiler) + "\n", "utf-8");
         stream.end();
     }
     catch (responseError) {

package/dist/server/plugins/registry.js

@@ -1,5 +1,6 @@
 import { pluginDefinitionRuntimeSchema, } from "../../schemas/plugin.js";
-import { PluginAlreadyRegisteredError, PluginDefinitionInvalidError, PluginLoggingInvalidError, } from "../../utils/errors-server.js";
+import { isModelTypeAlias } from "../../schemas/index.js";
+import { PluginAlreadyRegisteredError, PluginDefinitionInvalidError, PluginLoggingInvalidError, PluginModelTypeReservedError, } from "../../utils/errors-server.js";
 import { createAddonLoggerCallback } from "../../logging/addon.js";
 const plugins = new Map();
 function getModelTypeForError(plugin) {
@@ -23,6 +24,9 @@ function validatePluginDefinition(plugin) {
 }
 export function registerPlugin(plugin) {
     validatePluginDefinition(plugin);
+    if (isModelTypeAlias(plugin.modelType)) {
+        throw new PluginModelTypeReservedError(plugin.modelType);
+    }
     if (plugins.has(plugin.modelType)) {
         throw new PluginAlreadyRegisteredError(plugin.modelType);
     }

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

@@ -5,7 +5,15 @@
  * delegation to remote peers (via HyperSwarm RPC).
  */
 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>;
+import { DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, type Request, type Response, type RPCOptions, type DelegationBreakdown, type OperationEvent } from "../../schemas/index";
+import type { DelegatedHandlerOptions } from "./profiling/index";
+export interface DelegateOptions extends RPCOptions, DelegatedHandlerOptions {
+    peerKey?: string;
+}
+export type ResponseWithDelegation = Response & {
+    [DELEGATION_BREAKDOWN_KEY]?: DelegationBreakdown;
+    [OPERATION_EVENT_KEY]?: OperationEvent;
+};
+export declare function send<T extends Request>(request: T, rpc: RPC, options?: DelegateOptions): Promise<Response>;
+export declare function stream<T extends Request>(request: T, rpc: RPC, options?: DelegateOptions): AsyncGenerator<Response>;
 //# sourceMappingURL=delegate-transport.d.ts.map

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

@@ -4,10 +4,12 @@
  * 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 { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, buildDelegationStreamBreakdown, flushServerConnectionEvent, consumeBreakdownConnectionTime, } from "./profiling/delegation-profiler.js";
 const logger = getServerLogger();
 let commandCounter = 0;
 function getNextCommandId() {
@@ -20,10 +22,22 @@ function checkAndThrowError(response) {
     }
 }
 export async function send(request, rpc, options) {
+    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) {
     const parsedRequest = requestSchema.parse(request);
     const req = rpc.request(getNextCommandId());
     logger.debug("[delegate-transport] Sending:", { type: request.type });
-    const payload = JSON.stringify(parsedRequest);
+    // 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() || "{}"));
@@ -31,11 +45,82 @@ export async function send(request, rpc, options) {
     checkAndThrowError(resPayload);
     return resPayload;
 }
+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) {
+        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 { 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) {
     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");
+    // 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() {
@@ -58,3 +143,73 @@ export async function* stream(request, rpc, options = {}) {
         }
     }
 }
+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) {
+        const base = {
+            ts: nowMs(),
+            op: timings.requestType,
+            kind: "delegation",
+            profileId: timings.profileId,
+        };
+        recordFailure(base, timings.requestStart, error);
+        throw error;
+    }
+}