@qvac/sdk 0.6.0 → 0.7.0

package/dist/schemas/load-model.js

@@ -3,10 +3,15 @@ import { llmConfigBaseSchema, embedConfigBaseSchema, } from "./llamacpp-config.j
 import { whisperConfigSchema } from "./whispercpp-config.js";
 import { delegateSchema } from "./delegate.js";
 import { nmtConfigSchema } from "./translation-config.js";
-import { ttsConfigSchema } from "./text-to-speech.js";
+import { ttsConfigSchema, ttsChatterboxRequestConfigSchema, ttsSupertonicRequestConfigSchema, ttsRequestConfigSchema, } from "./text-to-speech.js";
 import { ocrConfigSchema } from "./ocr.js";
 import { modelSrcInputSchema, modelInputToSrcSchema, modelInputToNameSchema, } from "./model-src-utils.js";
-import { llmModelTypeSchema, whisperModelTypeSchema, embeddingsModelTypeSchema, nmtModelTypeSchema, ttsModelTypeSchema, ocrModelTypeSchema, ModelType, } from "./model-types.js";
+import { llmModelTypeSchema, whisperModelTypeSchema, embeddingsModelTypeSchema, nmtModelTypeSchema, ttsModelTypeSchema, ocrModelTypeSchema, ModelType, ModelTypeAliases, } from "./model-types.js";
+// Set of all built-in model types (canonical + aliases) for catch-all exclusion
+const builtInModelTypes = new Set([
+    ...Object.values(ModelType),
+    ...Object.keys(ModelTypeAliases),
+]);
 import { reloadConfigRequestSchema } from "./reload-config.js";
 const loadModelOptionsBaseSchema = z.union([
     z.object({
@@ -42,12 +47,11 @@ const loadModelOptionsBaseSchema = z.union([
         seed: z.boolean().optional(),
         delegate: delegateSchema,
     }),
+    // TTS (supports both Chatterbox and Supertonic via ttsEngine discriminator)
     z.object({
         modelSrc: modelSrcInputSchema,
         modelType: ttsModelTypeSchema,
         modelConfig: ttsConfigSchema,
-        configSrc: modelSrcInputSchema,
-        eSpeakDataPath: z.string(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
     }),
@@ -59,6 +63,16 @@ const loadModelOptionsBaseSchema = z.union([
         seed: z.boolean().optional(),
         delegate: delegateSchema,
     }),
+    // Custom plugin catch-all: accepts any modelType string EXCEPT built-ins
+    z.object({
+        modelSrc: modelSrcInputSchema,
+        modelType: z.string().refine((val) => !builtInModelTypes.has(val), {
+            message: "Built-in model types must use their specific schema",
+        }),
+        modelConfig: z.record(z.string(), z.unknown()).optional(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+    }),
 ]);
 export const loadModelOptionsSchema = loadModelOptionsBaseSchema.transform((data) => ({
     ...data,
@@ -167,25 +181,57 @@ export const loadModelOptionsToRequestSchema = z.union([
         modelSrc: modelSrcInputSchema,
         modelType: ttsModelTypeSchema,
         modelConfig: ttsConfigSchema,
-        configSrc: modelSrcInputSchema,
-        eSpeakDataPath: z.string(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
         onProgress: z.unknown().optional(),
         withProgress: z.boolean().optional(),
     })
-        .transform((data) => ({
-        type: "loadModel",
-        modelType: ModelType.onnxTts,
-        modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
-        modelName: modelInputToNameSchema.parse(data.modelSrc),
-        modelConfig: data.modelConfig,
-        seed: data.seed ?? false,
-        withProgress: data.withProgress ?? !!data.onProgress,
-        delegate: data.delegate,
-        configSrc: modelInputToSrcSchema.parse(data.configSrc),
-        eSpeakDataPath: data.eSpeakDataPath,
-    })),
+        .transform((data) => {
+        // Keep modelConfig intact, just convert ModelSrcInput values to strings
+        if (data.modelConfig.ttsEngine === "chatterbox") {
+            return {
+                type: "loadModel",
+                modelType: ModelType.onnxTts,
+                modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
+                modelName: modelInputToNameSchema.parse(data.modelSrc),
+                modelConfig: {
+                    ttsEngine: "chatterbox",
+                    language: data.modelConfig.language,
+                    ttsTokenizerSrc: modelInputToSrcSchema.parse(data.modelConfig.ttsTokenizerSrc),
+                    ttsSpeechEncoderSrc: modelInputToSrcSchema.parse(data.modelConfig.ttsSpeechEncoderSrc),
+                    ttsEmbedTokensSrc: modelInputToSrcSchema.parse(data.modelConfig.ttsEmbedTokensSrc),
+                    ttsConditionalDecoderSrc: modelInputToSrcSchema.parse(data.modelConfig.ttsConditionalDecoderSrc),
+                    ttsLanguageModelSrc: modelInputToSrcSchema.parse(data.modelConfig.ttsLanguageModelSrc),
+                    referenceAudioSrc: modelInputToSrcSchema.parse(data.modelConfig.referenceAudioSrc),
+                },
+                seed: data.seed ?? false,
+                withProgress: data.withProgress ?? !!data.onProgress,
+                delegate: data.delegate,
+            };
+        }
+        else {
+            return {
+                type: "loadModel",
+                modelType: ModelType.onnxTts,
+                modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
+                modelName: modelInputToNameSchema.parse(data.modelSrc),
+                modelConfig: {
+                    ttsEngine: "supertonic",
+                    language: data.modelConfig.language,
+                    ttsTokenizerSrc: modelInputToSrcSchema.parse(data.modelConfig.ttsTokenizerSrc),
+                    ttsTextEncoderSrc: modelInputToSrcSchema.parse(data.modelConfig.ttsTextEncoderSrc),
+                    ttsLatentDenoiserSrc: modelInputToSrcSchema.parse(data.modelConfig.ttsLatentDenoiserSrc),
+                    ttsVoiceDecoderSrc: modelInputToSrcSchema.parse(data.modelConfig.ttsVoiceDecoderSrc),
+                    ttsVoiceSrc: modelInputToSrcSchema.parse(data.modelConfig.ttsVoiceSrc),
+                    ttsSpeed: data.modelConfig.ttsSpeed,
+                    ttsNumInferenceSteps: data.modelConfig.ttsNumInferenceSteps,
+                },
+                seed: data.seed ?? false,
+                withProgress: data.withProgress ?? !!data.onProgress,
+                delegate: data.delegate,
+            };
+        }
+    }),
     z
         .object({
         modelSrc: modelSrcInputSchema,
@@ -210,6 +256,29 @@ export const loadModelOptionsToRequestSchema = z.union([
             ? modelInputToSrcSchema.parse(data.detectorModelSrc)
             : undefined,
     })),
+    // Custom plugin catch-all: accepts any modelType string EXCEPT built-ins
+    z
+        .object({
+        modelSrc: modelSrcInputSchema,
+        modelType: z.string().refine((val) => !builtInModelTypes.has(val), {
+            message: "Built-in model types must use their specific schema",
+        }),
+        modelConfig: z.record(z.string(), z.unknown()).optional(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+        onProgress: z.unknown().optional(),
+        withProgress: z.boolean().optional(),
+    })
+        .transform((data) => ({
+        type: "loadModel",
+        modelType: data.modelType,
+        modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
+        modelName: modelInputToNameSchema.parse(data.modelSrc),
+        modelConfig: data.modelConfig ?? {},
+        seed: data.seed ?? false,
+        withProgress: data.withProgress ?? !!data.onProgress,
+        delegate: data.delegate,
+    })),
 ]);
 const commonModelConfigSchema = z.object({
     type: z.literal("loadModel"),
@@ -217,7 +286,6 @@ const commonModelConfigSchema = z.object({
     modelName: z.string().optional(),
     projectionModelSrc: z.string().optional(),
     vadModelSrc: z.string().optional(),
-    configSrc: z.string().optional(),
     detectorModelSrc: z.string().optional(),
     withProgress: z.boolean().optional(),
     seed: z.boolean().optional(),
@@ -244,16 +312,29 @@ export const loadNmtModelRequestSchema = commonModelConfigSchema.extend({
     srcVocabSrc: z.string().optional(),
     dstVocabSrc: z.string().optional(),
 });
+export const loadTtsChatterboxModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal(ModelType.onnxTts),
+    modelConfig: ttsChatterboxRequestConfigSchema,
+});
+export const loadTtsSupertonicModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal(ModelType.onnxTts),
+    modelConfig: ttsSupertonicRequestConfigSchema,
+});
 export const loadTtsModelRequestSchema = commonModelConfigSchema.extend({
     modelType: z.literal(ModelType.onnxTts),
-    modelConfig: ttsConfigSchema, // tts has no defaults
-    configSrc: z.string(),
-    eSpeakDataPath: z.string(),
+    modelConfig: ttsRequestConfigSchema,
 });
 export const loadOcrModelRequestSchema = commonModelConfigSchema.extend({
     modelType: z.literal(ModelType.onnxOcr),
     modelConfig: ocrConfigSchema, // ocr has no defaults
 });
+// Custom plugin catch-all: accepts any modelType string EXCEPT built-ins
+export const loadCustomPluginModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.string().refine((val) => !builtInModelTypes.has(val), {
+        message: "Built-in model types must use their specific schema",
+    }),
+    modelConfig: z.record(z.string(), z.unknown()).optional(),
+});
 // Union of all load model request types (using z.union since each modelType accepts multiple values)
 export const loadModelSrcRequestSchema = z
     .union([
@@ -263,6 +344,7 @@ export const loadModelSrcRequestSchema = z
     loadNmtModelRequestSchema,
     loadTtsModelRequestSchema,
     loadOcrModelRequestSchema,
+    loadCustomPluginModelRequestSchema,
 ])
     .transform((data) => ({
     ...data,
@@ -295,6 +377,16 @@ export const modelProgressUpdateSchema = z.object({
         overallPercentage: z.number(),
     })
         .optional(),
+    onnxInfo: z
+        .object({
+        currentFile: z.string(),
+        fileIndex: z.number(),
+        totalFiles: z.number(),
+        overallDownloaded: z.number(),
+        overallTotal: z.number(),
+        overallPercentage: z.number(),
+    })
+        .optional(),
 });
 export const hyperdriveUrlSchema = z
     .string()
@@ -303,14 +395,27 @@ export const hyperdriveUrlSchema = z
     const match = url.match(/^pear:\/\/([0-9a-fA-F]{64})\/(.+)$/);
     return { key: match[1], path: match[2] };
 });
+/**
+ * Schema for registry:// URLs (internal use only).
+ * Users should use model constants from @qvac/sdk instead of raw URLs.
+ * Format: registry://source/path/to/model.gguf
+ */
+export const registryUrlSchema = z
+    .string()
+    .regex(/^registry:\/\/([^/]+)\/(.+)$/, "Invalid registry URL. Expected format: registry://source/path/to/model.gguf")
+    .transform((url) => {
+    const match = url.match(/^registry:\/\/([^/]+)\/(.+)$/);
+    return {
+        registrySource: match[1],
+        registryPath: match[2], // Path without source prefix
+    };
+});
 export const loadModelServerParamsSchema = z.object({
     modelId: z.string(),
     modelPath: z.string(),
-    options: loadModelOptionsSchema,
+    options: loadModelSrcRequestSchema,
     projectionModelPath: z.string().optional(),
     vadModelPath: z.string().optional(),
-    ttsConfigModelPath: z.string().optional(),
-    eSpeakDataPath: z.string().optional(),
     detectorModelPath: z.string().optional(),
     modelName: z.string().optional(),
 });

package/dist/schemas/model-src-utils.d.ts

@@ -3,8 +3,11 @@ export declare const modelDescriptorSchema: z.ZodObject<{
     src: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
     modelId: z.ZodOptional<z.ZodString>;
-    hyperdriveKey: z.ZodOptional<z.ZodString>;
-    hyperbeeKey: z.ZodOptional<z.ZodString>;
+    registryPath: z.ZodOptional<z.ZodString>;
+    registrySource: z.ZodOptional<z.ZodString>;
+    blobCoreKey: z.ZodOptional<z.ZodString>;
+    blobIndex: z.ZodOptional<z.ZodNumber>;
+    engine: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
     addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
@@ -26,8 +29,11 @@ export declare const modelSrcInputSchema: z.ZodUnion<readonly [z.ZodString, z.Zo
     src: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
     modelId: z.ZodOptional<z.ZodString>;
-    hyperdriveKey: z.ZodOptional<z.ZodString>;
-    hyperbeeKey: z.ZodOptional<z.ZodString>;
+    registryPath: z.ZodOptional<z.ZodString>;
+    registrySource: z.ZodOptional<z.ZodString>;
+    blobCoreKey: z.ZodOptional<z.ZodString>;
+    blobIndex: z.ZodOptional<z.ZodNumber>;
+    engine: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
     addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
@@ -55,8 +61,11 @@ export declare const modelInputToSrcSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zod
     src: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
     modelId: z.ZodOptional<z.ZodString>;
-    hyperdriveKey: z.ZodOptional<z.ZodString>;
-    hyperbeeKey: z.ZodOptional<z.ZodString>;
+    registryPath: z.ZodOptional<z.ZodString>;
+    registrySource: z.ZodOptional<z.ZodString>;
+    blobCoreKey: z.ZodOptional<z.ZodString>;
+    blobIndex: z.ZodOptional<z.ZodNumber>;
+    engine: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
     addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
@@ -77,8 +86,11 @@ export declare const modelInputToSrcSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zod
     src: string;
     name?: string | undefined;
     modelId?: string | undefined;
-    hyperdriveKey?: string | undefined;
-    hyperbeeKey?: string | undefined;
+    registryPath?: string | undefined;
+    registrySource?: string | undefined;
+    blobCoreKey?: string | undefined;
+    blobIndex?: number | undefined;
+    engine?: string | undefined;
     expectedSize?: number | undefined;
     sha256Checksum?: string | undefined;
     addon?: "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr" | "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "ocr" | "vad" | undefined;
@@ -91,8 +103,11 @@ export declare const modelInputToNameSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zo
     src: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
     modelId: z.ZodOptional<z.ZodString>;
-    hyperdriveKey: z.ZodOptional<z.ZodString>;
-    hyperbeeKey: z.ZodOptional<z.ZodString>;
+    registryPath: z.ZodOptional<z.ZodString>;
+    registrySource: z.ZodOptional<z.ZodString>;
+    blobCoreKey: z.ZodOptional<z.ZodString>;
+    blobIndex: z.ZodOptional<z.ZodNumber>;
+    engine: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
     addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
@@ -113,8 +128,11 @@ export declare const modelInputToNameSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zo
     src: string;
     name?: string | undefined;
     modelId?: string | undefined;
-    hyperdriveKey?: string | undefined;
-    hyperbeeKey?: string | undefined;
+    registryPath?: string | undefined;
+    registrySource?: string | undefined;
+    blobCoreKey?: string | undefined;
+    blobIndex?: number | undefined;
+    engine?: string | undefined;
     expectedSize?: number | undefined;
     sha256Checksum?: string | undefined;
     addon?: "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr" | "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "ocr" | "vad" | undefined;

package/dist/schemas/model-src-utils.js

@@ -6,8 +6,11 @@ export const modelDescriptorSchema = z.object({
     src: z.string(),
     name: z.string().optional(),
     modelId: z.string().optional(),
-    hyperdriveKey: z.string().optional(),
-    hyperbeeKey: z.string().optional(),
+    registryPath: z.string().optional(),
+    registrySource: z.string().optional(),
+    blobCoreKey: z.string().optional(),
+    blobIndex: z.number().optional(),
+    engine: z.string().optional(),
     expectedSize: z.number().optional(),
     sha256Checksum: z.string().optional(),
     addon: addonSchema.optional(),

package/dist/schemas/model-types.d.ts

@@ -87,10 +87,21 @@ export declare const modelTypeSchema: z.ZodPipe<z.ZodEnum<{
     tts: "tts";
     ocr: "ocr";
 }>, z.ZodTransform<"llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr", "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr" | "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "ocr">>;
-/** Normalize model type input to canonical form */
-export declare function normalizeModelType(input: ModelTypeInput): CanonicalModelType;
-/** Check if input is an alias (not canonical) */
-export declare function isModelTypeAlias(input: ModelTypeInput): boolean;
+/**
+ * Normalize model type input to canonical form.
+ * Custom plugin types (not in built-ins) are returned as-is.
+ */
+export declare function normalizeModelType(input: string): string;
+/**
+ * Type guard to check if a string is a canonical (built-in) model type.
+ * Returns false for custom plugin types.
+ */
+export declare function isCanonicalModelType(input: string): input is CanonicalModelType;
+/**
+ * Check if input is a built-in alias (not canonical or custom).
+ * Returns false for custom plugin types.
+ */
+export declare function isModelTypeAlias(input: string): boolean;
 /**
  * LLM/Completion model type schema.
  * - Alias: `"llm"` → resolves to `"llamacpp-completion"`

package/dist/schemas/model-types.js

@@ -75,16 +75,33 @@ export const modelTypeSchema = modelTypeInputSchema.transform((val) => {
     // Otherwise, look up in aliases
     return ModelTypeAliases[val];
 });
-/** Normalize model type input to canonical form */
+/**
+ * Normalize model type input to canonical form.
+ * Custom plugin types (not in built-ins) are returned as-is.
+ */
 export function normalizeModelType(input) {
     // If already canonical, return as-is
     if (canonicalValuesSet.has(input)) {
         return input;
     }
-    // Otherwise, look up in aliases
-    return ModelTypeAliases[input];
+    // If it's an alias, normalize to canonical
+    if (input in ModelTypeAliases) {
+        return ModelTypeAliases[input];
+    }
+    // Custom plugin type - return as-is
+    return input;
 }
-/** Check if input is an alias (not canonical) */
+/**
+ * Type guard to check if a string is a canonical (built-in) model type.
+ * Returns false for custom plugin types.
+ */
+export function isCanonicalModelType(input) {
+    return canonicalValuesSet.has(input);
+}
+/**
+ * Check if input is a built-in alias (not canonical or custom).
+ * Returns false for custom plugin types.
+ */
 export function isModelTypeAlias(input) {
     return input in ModelTypeAliases;
 }

package/dist/schemas/path-validation.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+/**
+ * Zod refinement for path components that get joined to a base directory.
+ * Rejects strings containing traversal sequences (.., null bytes).
+ *
+ * DO NOT apply to fields that accept absolute user paths (e.g. audio, image,
+ * model, or attachment paths).
+ */
+export declare const safePathComponent: z.ZodString;
+//# sourceMappingURL=path-validation.d.ts.map

package/dist/schemas/path-validation.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+/**
+ * Zod refinement for path components that get joined to a base directory.
+ * Rejects strings containing traversal sequences (.., null bytes).
+ *
+ * DO NOT apply to fields that accept absolute user paths (e.g. audio, image,
+ * model, or attachment paths).
+ */
+export const safePathComponent = z.string().refine((s) => {
+    // Reject literal traversal
+    if (s.includes(".."))
+        return false;
+    // Reject null bytes (literal and URL-encoded)
+    if (s.includes("\0") || s.toLowerCase().includes("%00"))
+        return false;
+    // Reject URL-encoded traversal (%2e = ".", %2f = "/", %5c = "\")
+    if (/%2e/i.test(s))
+        return false;
+    return true;
+}, {
+    message: "Path component must not contain traversal sequences ('..', '%2e'), null bytes, or '%00'",
+});

package/dist/schemas/plugin.d.ts

@@ -0,0 +1,180 @@
+import { z } from "zod";
+/**
+ * Definition for a plugin handler with explicit Zod schemas.
+ * Each handler must define its request/response schemas for validation.
+ */
+export interface PluginHandlerDefinition<TRequest extends z.ZodType = z.ZodType, TResponse extends z.ZodType = z.ZodType> {
+    requestSchema: TRequest;
+    responseSchema: TResponse;
+    streaming: boolean;
+    /** The handler function - receives validated request, returns validated response */
+    handler: TRequest extends z.ZodType<infer I> ? TResponse extends z.ZodType<infer O> ? (request: I) => Promise<O> | AsyncGenerator<O> : never : never;
+}
+/**
+ * Parameters passed to createModel when loading a plugin model.
+ *
+ * Core fields are always present. The `artifacts` map contains
+ * additional file paths required by specific plugins (e.g., projection
+ * models, VAD models, config files).
+ *
+ * Built-in artifact keys:
+ * - `projectionModelPath` - LLM multimodal projection model
+ * - `vadModelPath` - Whisper voice activity detection model
+ * - `tokenizerPath`, `speechEncoderPath`, `embedTokensPath`, `conditionalDecoderPath`, `languageModelPath` - TTS (Chatterbox) model files
+ * - `referenceAudioPath` - TTS (Chatterbox) path to reference WAV file for voice cloning
+ * - `tokenizerPath`, `textEncoderPath`, `latentDenoiserPath`, `voiceDecoderPath` - TTS (Supertonic) model files
+ * - `voicePath` - TTS (Supertonic) path to voice .bin file (e.g. voices/M1.bin)
+ * - `speed`, `numInferenceSteps` - TTS (Supertonic) options
+ * - `detectorModelPath` - OCR detector model
+ *
+ * Custom plugins can define their own artifact keys.
+ */
+export interface CreateModelParams {
+    modelId: string;
+    modelPath: string;
+    modelConfig?: Record<string, unknown> | undefined;
+    modelName?: string | undefined;
+    artifacts?: Record<string, string> | undefined;
+}
+/**
+ * Minimal contract for plugin models.
+ * All models must implement `load()`. `unload()` is optional.
+ */
+export interface PluginModel {
+    load(force?: boolean): Promise<void>;
+    unload?(): void | Promise<void>;
+}
+export interface PluginModelResult {
+    model: PluginModel;
+    loader: unknown;
+}
+export interface PluginLogging {
+    module: unknown;
+    namespace: string;
+}
+/**
+ * Function to resolve a model source (URL or path) to a local file path.
+ * Passed to resolveConfig hook to allow plugins to resolve their artifacts.
+ */
+export type ResolveModelPath = (src: string) => Promise<string>;
+export interface QvacPlugin {
+    modelType: string;
+    displayName: string;
+    addonPackage: string;
+    createModel: (params: CreateModelParams) => PluginModelResult;
+    handlers: Record<string, PluginHandlerDefinition>;
+    logging?: PluginLogging | undefined;
+    /**
+     * Optional hook to resolve model sources in modelConfig to local paths.
+     * Called before createModel if the plugin needs to download/resolve artifacts.
+     * Receives the raw modelConfig and a resolve function, returns transformed config.
+     */
+    resolveConfig?: (modelConfig: Record<string, unknown>, resolve: ResolveModelPath) => Promise<Record<string, unknown>>;
+}
+export declare const pluginInvokeRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pluginInvoke">;
+    modelId: z.ZodString;
+    handler: z.ZodString;
+    params: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const pluginInvokeResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pluginInvoke">;
+    result: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const pluginInvokeStreamRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pluginInvokeStream">;
+    modelId: z.ZodString;
+    handler: z.ZodString;
+    params: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const pluginInvokeStreamResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pluginInvokeStream">;
+    result: z.ZodUnknown;
+    done: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PluginInvokeRequest = z.infer<typeof pluginInvokeRequestSchema>;
+export type PluginInvokeResponse = z.infer<typeof pluginInvokeResponseSchema>;
+export type PluginInvokeStreamRequest = z.infer<typeof pluginInvokeStreamRequestSchema>;
+export type PluginInvokeStreamResponse = z.infer<typeof pluginInvokeStreamResponseSchema>;
+/**
+ * Helper function to define a plugin with full type inference.
+ * This is an identity function that provides type checking.
+ */
+export declare function definePlugin<T extends QvacPlugin>(plugin: T): T;
+/**
+ * Helper function to define a handler with full type inference.
+ * This is an identity function that provides type checking.
+ */
+export declare function defineHandler<TRequest extends z.ZodType, TResponse extends z.ZodType>(definition: PluginHandlerDefinition<TRequest, TResponse>): PluginHandlerDefinition<TRequest, TResponse>;
+export declare const pluginHandlerDefinitionRuntimeSchema: z.ZodObject<{
+    requestSchema: z.ZodObject<{
+        safeParse: z.ZodCustom<Function, Function>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+    responseSchema: z.ZodObject<{
+        safeParse: z.ZodCustom<Function, Function>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+    streaming: z.ZodBoolean;
+    handler: z.ZodCustom<Function, Function>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const pluginDefinitionRuntimeSchema: z.ZodObject<{
+    modelType: z.ZodString;
+    displayName: z.ZodString;
+    addonPackage: z.ZodString;
+    createModel: z.ZodCustom<Function, Function>;
+    handlers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        requestSchema: z.ZodObject<{
+            safeParse: z.ZodCustom<Function, Function>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+        responseSchema: z.ZodObject<{
+            safeParse: z.ZodCustom<Function, Function>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+        streaming: z.ZodBoolean;
+        handler: z.ZodCustom<Function, Function>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+    logging: z.ZodOptional<z.ZodObject<{
+        module: z.ZodOptional<z.ZodUnknown>;
+        namespace: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+/**
+ * LLM text completion plugin (llama.cpp).
+ * Provides: completion, streaming chat, tool calling.
+ */
+export declare const PLUGIN_LLM: "@qvac/sdk/llamacpp-completion/plugin";
+/**
+ * Text embedding plugin (llama.cpp).
+ * Provides: vector embeddings for RAG and semantic search.
+ */
+export declare const PLUGIN_EMBEDDING: "@qvac/sdk/llamacpp-embedding/plugin";
+/**
+ * Speech-to-text transcription plugin (whisper.cpp).
+ * Provides: audio transcription, language detection.
+ */
+export declare const PLUGIN_WHISPER: "@qvac/sdk/whispercpp-transcription/plugin";
+/**
+ * Neural machine translation plugin (nmt.cpp).
+ * Provides: text translation between languages.
+ */
+export declare const PLUGIN_NMT: "@qvac/sdk/nmtcpp-translation/plugin";
+/**
+ * Text-to-speech synthesis plugin (ONNX).
+ * Provides: speech synthesis from text.
+ */
+export declare const PLUGIN_TTS: "@qvac/sdk/onnx-tts/plugin";
+/**
+ * Optical character recognition plugin (ONNX).
+ * Provides: text extraction from images.
+ */
+export declare const PLUGIN_OCR: "@qvac/sdk/onnx-ocr/plugin";
+/**
+ * All built-in SDK plugins.
+ *
+ * @example
+ * // Use all defaults plus a custom plugin:
+ * const config = {
+ *   plugins: [...SDK_DEFAULT_PLUGINS, myCustomPlugin],
+ * };
+ */
+export declare const SDK_DEFAULT_PLUGINS: readonly ["@qvac/sdk/llamacpp-completion/plugin", "@qvac/sdk/llamacpp-embedding/plugin", "@qvac/sdk/whispercpp-transcription/plugin", "@qvac/sdk/nmtcpp-translation/plugin", "@qvac/sdk/onnx-tts/plugin", "@qvac/sdk/onnx-ocr/plugin"];
+export type BuiltinPlugin = (typeof SDK_DEFAULT_PLUGINS)[number];
+//# sourceMappingURL=plugin.d.ts.map