@qvac/sdk 0.7.1 → 0.8.1

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

@@ -0,0 +1,154 @@
+import parakeetAddonLogging from "@qvac/transcription-parakeet/addonLogging.js";
+import TranscriptionParakeet, {} from "@qvac/transcription-parakeet";
+import { definePlugin, defineHandler, transcribeStreamRequestSchema, transcribeStreamResponseSchema, ModelType, parakeetConfigSchema, ADDON_PARAKEET, } from "../../../../schemas/index.js";
+import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
+import { parseModelPath } from "../../../utils/index.js";
+import { ModelLoadFailedError, ParakeetArtifactsRequiredError, } from "../../../../utils/errors-server.js";
+import FilesystemDL from "@qvac/dl-filesystem";
+import { transcribe } from "../../ops/transcribe.js";
+async function resolveTdtConfig(cfg, ctx) {
+    const { parakeetEncoderSrc, parakeetEncoderDataSrc, parakeetDecoderSrc, parakeetVocabSrc, parakeetPreprocessorSrc, } = cfg;
+    if (!parakeetEncoderSrc ||
+        !parakeetDecoderSrc ||
+        !parakeetVocabSrc ||
+        !parakeetPreprocessorSrc) {
+        throw new ParakeetArtifactsRequiredError("TDT requires: parakeetEncoderSrc, parakeetDecoderSrc, parakeetVocabSrc, parakeetPreprocessorSrc");
+    }
+    const resolve = ctx.resolveModelPath;
+    const [encoderPath, encoderDataPath, decoderPath, vocabPath, preprocessorPath,] = await Promise.all([
+        resolve(parakeetEncoderSrc),
+        parakeetEncoderDataSrc ? resolve(parakeetEncoderDataSrc) : undefined,
+        resolve(parakeetDecoderSrc),
+        resolve(parakeetVocabSrc),
+        resolve(parakeetPreprocessorSrc),
+    ]);
+    return {
+        config: cfg,
+        artifacts: {
+            encoderPath,
+            ...(encoderDataPath !== undefined && { encoderDataPath }),
+            ...(decoderPath !== undefined && { decoderPath }),
+            ...(vocabPath !== undefined && { vocabPath }),
+            ...(preprocessorPath !== undefined && { preprocessorPath }),
+        },
+    };
+}
+async function resolveCtcConfig(cfg, ctx) {
+    const { parakeetCtcModelSrc, parakeetCtcModelDataSrc, parakeetTokenizerSrc } = cfg;
+    if (!parakeetCtcModelSrc || !parakeetTokenizerSrc) {
+        throw new ParakeetArtifactsRequiredError("CTC requires: parakeetCtcModelSrc, parakeetTokenizerSrc");
+    }
+    const resolve = ctx.resolveModelPath;
+    const [ctcModelPath, ctcModelDataPath, tokenizerPath] = await Promise.all([
+        resolve(parakeetCtcModelSrc),
+        parakeetCtcModelDataSrc ? resolve(parakeetCtcModelDataSrc) : undefined,
+        resolve(parakeetTokenizerSrc),
+    ]);
+    return {
+        config: cfg,
+        artifacts: {
+            ctcModelPath,
+            ...(ctcModelDataPath !== undefined && { ctcModelDataPath }),
+            ...(tokenizerPath !== undefined && { tokenizerPath }),
+        },
+    };
+}
+async function resolveSortformerConfig(cfg, ctx) {
+    const { parakeetSortformerSrc } = cfg;
+    if (!parakeetSortformerSrc) {
+        throw new ParakeetArtifactsRequiredError("Sortformer requires: parakeetSortformerSrc");
+    }
+    const resolve = ctx.resolveModelPath;
+    const sortformerPath = await resolve(parakeetSortformerSrc);
+    return {
+        config: cfg,
+        artifacts: {
+            ...(sortformerPath !== undefined && { sortformerPath }),
+        },
+    };
+}
+function createParakeetModel(params, addonPathKey) {
+    const config = (params.modelConfig ?? {});
+    const artifacts = params.artifacts ?? {};
+    const modelType = config.modelType ?? "tdt";
+    const primaryPath = artifacts[addonPathKey] ?? params.modelPath;
+    if (!primaryPath) {
+        throw new ModelLoadFailedError(`Parakeet ${modelType} requires a model source`);
+    }
+    const { dirPath } = parseModelPath(primaryPath);
+    const loader = new FilesystemDL({ dirPath });
+    const logger = createStreamLogger(params.modelId, ModelType.parakeetTranscription);
+    registerAddonLogger(params.modelId, ModelType.parakeetTranscription, logger);
+    const addonConfig = {
+        path: dirPath,
+        [addonPathKey]: primaryPath,
+        ...artifacts,
+        parakeetConfig: {
+            modelType,
+            maxThreads: config.maxThreads,
+            useGPU: config.useGPU,
+            sampleRate: config.sampleRate,
+            channels: config.channels,
+            captionEnabled: config.captionEnabled,
+            timestampsEnabled: config.timestampsEnabled,
+        },
+    };
+    const model = new TranscriptionParakeet({
+        loader,
+        logger,
+        modelName: parseModelPath(dirPath).basePath,
+        diskPath: dirPath,
+    }, addonConfig);
+    return { model, loader };
+}
+export const parakeetPlugin = definePlugin({
+    modelType: ModelType.parakeetTranscription,
+    displayName: "Parakeet (NVIDIA NeMo ONNX)",
+    addonPackage: ADDON_PARAKEET,
+    loadConfigSchema: parakeetConfigSchema,
+    skipPrimaryModelPathValidation: true,
+    async resolveConfig(cfg, ctx) {
+        const modelType = cfg.modelType ?? "tdt";
+        if (modelType === "ctc")
+            return resolveCtcConfig(cfg, ctx);
+        if (modelType === "sortformer")
+            return resolveSortformerConfig(cfg, ctx);
+        return resolveTdtConfig(cfg, ctx);
+    },
+    createModel(params) {
+        const modelType = (params.modelConfig ?? {}).modelType ?? "tdt";
+        if (modelType === "ctc")
+            return createParakeetModel(params, "ctcModelPath");
+        if (modelType === "sortformer")
+            return createParakeetModel(params, "sortformerPath");
+        return createParakeetModel(params, "encoderPath");
+    },
+    handlers: {
+        transcribeStream: defineHandler({
+            requestSchema: transcribeStreamRequestSchema,
+            responseSchema: transcribeStreamResponseSchema,
+            streaming: true,
+            handler: async function* (request) {
+                for await (const text of transcribe({
+                    modelId: request.modelId,
+                    audioChunk: request.audioChunk,
+                    prompt: request.prompt,
+                })) {
+                    yield {
+                        type: "transcribeStream",
+                        text,
+                    };
+                }
+                yield {
+                    type: "transcribeStream",
+                    text: "",
+                    done: true,
+                };
+            },
+        }),
+    },
+    logging: {
+        module: parakeetAddonLogging,
+        namespace: ModelType.parakeetTranscription,
+    },
+});

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/registry/model-registry.d.ts

@@ -12,6 +12,7 @@ interface DelegateOptions {
     topic: string;
     providerPublicKey: string;
     timeout?: number | undefined;
+    healthCheckTimeout?: number | undefined;
 }
 interface LocalOptions {
     model: AnyModel;
@@ -39,6 +40,7 @@ export declare function registerModel(id: string, options: {
     topic: string;
     providerPublicKey: string;
     timeout?: number;
+    healthCheckTimeout?: number;
 }): void;
 export declare function getModelEntry(id: string): ModelEntry | null;
 export declare function getModel(id: string): AnyModel;

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

@@ -9,7 +9,7 @@ export function registerModel(id, options) {
     }
     const isDelegated = "topic" in options && "providerPublicKey" in options;
     if (isDelegated) {
-        const { topic, providerPublicKey, timeout } = options;
+        const { topic, providerPublicKey, timeout, healthCheckTimeout } = options;
         modelRegistry.set(id, {
             id,
             isDelegated: true,
@@ -17,6 +17,7 @@ export function registerModel(id, options) {
                 topic,
                 providerPublicKey,
                 timeout,
+                healthCheckTimeout,
             },
         });
         logger.info(`Delegated model registered: ${id} -> topic: ${topic}, provider: ${providerPublicKey}, timeout: ${timeout}ms`);

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