@qvac/sdk 0.6.0 → 0.7.0

package/dist/schemas/text-to-speech.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { modelSrcInputSchema } from "./model-src-utils.js";
 // TTS supported languages based on available models
 export const TTS_LANGUAGES = [
     "en", // English
@@ -6,13 +7,61 @@ export const TTS_LANGUAGES = [
     "de", // German
     "it", // Italian
 ];
-export const ttsConfigSchema = z.object({
+export const ttsChatterboxConfigSchema = z.object({
+    ttsEngine: z.literal("chatterbox"),
     language: z.enum(TTS_LANGUAGES),
+    ttsTokenizerSrc: modelSrcInputSchema,
+    ttsSpeechEncoderSrc: modelSrcInputSchema,
+    ttsEmbedTokensSrc: modelSrcInputSchema,
+    ttsConditionalDecoderSrc: modelSrcInputSchema,
+    ttsLanguageModelSrc: modelSrcInputSchema,
+    referenceAudioSrc: modelSrcInputSchema,
 });
+export const ttsSupertonicConfigSchema = z.object({
+    ttsEngine: z.literal("supertonic"),
+    language: z.enum(TTS_LANGUAGES),
+    ttsTokenizerSrc: modelSrcInputSchema,
+    ttsTextEncoderSrc: modelSrcInputSchema,
+    ttsLatentDenoiserSrc: modelSrcInputSchema,
+    ttsVoiceDecoderSrc: modelSrcInputSchema,
+    ttsVoiceSrc: modelSrcInputSchema,
+    ttsSpeed: z.number().optional(),
+    ttsNumInferenceSteps: z.number().optional(),
+});
+export const ttsConfigSchema = z.union([
+    ttsChatterboxConfigSchema,
+    ttsSupertonicConfigSchema,
+]);
+// Request-level schemas with string sources (after ModelSrcInput is resolved to string)
+export const ttsChatterboxRequestConfigSchema = z.object({
+    ttsEngine: z.literal("chatterbox"),
+    language: z.enum(TTS_LANGUAGES),
+    ttsTokenizerSrc: z.string(),
+    ttsSpeechEncoderSrc: z.string(),
+    ttsEmbedTokensSrc: z.string(),
+    ttsConditionalDecoderSrc: z.string(),
+    ttsLanguageModelSrc: z.string(),
+    referenceAudioSrc: z.string(),
+});
+export const ttsSupertonicRequestConfigSchema = z.object({
+    ttsEngine: z.literal("supertonic"),
+    language: z.enum(TTS_LANGUAGES),
+    ttsTokenizerSrc: z.string(),
+    ttsTextEncoderSrc: z.string(),
+    ttsLatentDenoiserSrc: z.string(),
+    ttsVoiceDecoderSrc: z.string(),
+    ttsVoiceSrc: z.string(),
+    ttsSpeed: z.number().optional(),
+    ttsNumInferenceSteps: z.number().optional(),
+});
+export const ttsRequestConfigSchema = z.union([
+    ttsChatterboxRequestConfigSchema,
+    ttsSupertonicRequestConfigSchema,
+]);
 export const ttsClientParamsSchema = z.object({
     modelId: z.string(),
     inputType: z.string().default("text"),
-    text: z.string(),
+    text: z.string().trim().min(1, "text must not be empty or whitespace-only"),
     stream: z.boolean().default(true),
 });
 export const ttsRequestSchema = ttsClientParamsSchema.extend({

package/dist/schemas/translate.d.ts

@@ -67,12 +67,12 @@ export declare const translateServerParamsSchema: z.ZodPipe<z.ZodUnion<readonly
     to: z.ZodString;
     context: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>]>, z.ZodTransform<{
-    modelType: import("./model-types").CanonicalModelType;
+    modelType: string;
     modelId: string;
     text: string | string[];
     stream: boolean;
 } | {
-    modelType: import("./model-types").CanonicalModelType;
+    modelType: string;
     modelId: string;
     text: string;
     stream: boolean;

package/dist/scripts/run-security-tests-bare.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=run-security-tests-bare.d.ts.map

package/dist/scripts/run-security-tests-bare.js

@@ -0,0 +1,78 @@
+import { readdirSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { join, dirname, relative } from "path";
+import { spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = join(__dirname, "..");
+const testDistRoot = join(pkgRoot, "test", "dist");
+const testDistDir = join(testDistRoot, "test", "unit");
+// Step 1: Compile
+console.log("Compiling tests...");
+spawnSync("rm", ["-rf", testDistRoot], { cwd: pkgRoot });
+const compile = spawnSync("tsc", ["--project", join(pkgRoot, "test", "tsconfig.json")], {
+    stdio: "inherit",
+    cwd: pkgRoot,
+});
+// tsc exits non-zero for pre-existing issues in other test files (unused @ts-expect-error,
+// index signature access, etc.) but emits JS via noEmitOnError: false — verify output exists
+if (compile.status !== 0 && !existsSync(testDistDir)) {
+    console.error("Test compilation failed — no output produced");
+    process.exit(1);
+}
+// Step 2: Resolve @/ aliases in compiled output
+function walk(dir) {
+    const results = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory())
+            results.push(...walk(full));
+        else if (entry.name.endsWith(".js"))
+            results.push(full);
+    }
+    return results;
+}
+function resolveTarget(fromFile, spec) {
+    const target = join(testDistRoot, spec);
+    let rel = relative(dirname(fromFile), target).split("\\").join("/");
+    if (!rel.startsWith("."))
+        rel = `./${rel}`;
+    if (existsSync(`${target}.js`))
+        return `${rel}.js`;
+    if (existsSync(join(target, "index.js")))
+        return `${rel}/index.js`;
+    return `${rel}.js`;
+}
+for (const file of walk(testDistRoot)) {
+    const content = readFileSync(file, "utf-8");
+    let updated = content;
+    // Static imports/exports: from "../....js"
+    updated = updated.replace(/((?:from|import)\s*["'])@\/([^"']+)(["'])/g, (_m, pre, spec, suf) => `${pre}${resolveTarget(file, spec)}${suf}`);
+    // Dynamic imports: import("../....js")
+    updated = updated.replace(/(import\s*\(\s*["'])@\/([^"']+)(["']\s*\))/g, (_m, pre, spec, suf) => `${pre}${resolveTarget(file, spec)}${suf}`);
+    if (updated !== content)
+        writeFileSync(file, updated);
+}
+// Step 3: Run under Bare
+if (!existsSync(testDistDir)) {
+    console.error(`Test dist not found: ${testDistDir}`);
+    process.exit(1);
+}
+const testFiles = readdirSync(testDistDir).filter((f) => (f.startsWith("path-traversal") || f.startsWith("path-security")) &&
+    f.endsWith(".test.js"));
+if (testFiles.length === 0) {
+    console.log("No compiled security test files found.");
+    process.exit(0);
+}
+const brittleBare = join(pkgRoot, "node_modules", ".bin", "brittle-bare");
+let hasFailure = false;
+for (const file of testFiles) {
+    const testPath = relative(pkgRoot, join(testDistDir, file));
+    console.log(`\nRunning under Bare: ${file}`);
+    const result = spawnSync(brittleBare, [testPath], {
+        stdio: "inherit",
+        cwd: pkgRoot,
+    });
+    if (result.status !== 0)
+        hasFailure = true;
+}
+process.exit(hasFailure ? 1 : 0);

package/dist/scripts/run-security-tests.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=run-security-tests.d.ts.map

package/dist/scripts/run-security-tests.js

@@ -0,0 +1,22 @@
+import { readdirSync } from "fs";
+import { join, dirname } from "path";
+import { spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const testDir = join(__dirname, "..", "test", "unit");
+const testFiles = readdirSync(testDir).filter((f) => (f.startsWith("path-traversal") || f.startsWith("path-security")) &&
+    f.endsWith(".test.ts"));
+if (testFiles.length === 0) {
+    console.log("No security tests found.");
+    process.exit(0);
+}
+let hasFailure = false;
+for (const file of testFiles) {
+    const result = spawnSync("bun", ["run", join(testDir, file)], {
+        stdio: "inherit",
+    });
+    if (result.status !== 0) {
+        hasFailure = true;
+    }
+}
+process.exit(hasFailure ? 1 : 0);

package/dist/server/bare/delegate-rpc-client.d.ts

@@ -1,4 +1,10 @@
 import RPC from "bare-rpc";
 import type { RPCOptions } from "../../schemas/index";
 export declare function getRPC(topic: string, publicKey: string, options?: RPCOptions): Promise<RPC>;
+/**
+ * Remove a stale RPC connection for a peer.
+ * Called when a delegation request fails (e.g., timeout) so the next
+ * attempt creates a fresh connection instead of reusing a dead RPC.
+ */
+export declare function cleanupStaleConnection(publicKey: string): void;
 //# sourceMappingURL=delegate-rpc-client.d.ts.map

package/dist/server/bare/delegate-rpc-client.js

@@ -8,67 +8,23 @@ const logger = getServerLogger();
 const activeRPCs = new Map();
 // Map to store underlying connections for cleanup
 const activeConnections = new Map();
-function closeConnection(publicKey) {
-    const existingConnection = activeConnections.get(publicKey);
-    if (existingConnection) {
-        logger.info(`🔌 Closing existing connection for peer: ${publicKey}`);
-        existingConnection.destroy();
-        activeConnections.delete(publicKey);
-        activeRPCs.delete(publicKey);
-    }
-}
-// Establish RPC connection to a peer if not already connected
-async function ensureRPCConnection(topic, publicKey, timeout) {
-    // Check if we already have an RPC instance for this peer
-    let rpc = activeRPCs.get(publicKey);
+// Track whether the global connection handler has been registered
+let connectionHandlerRegistered = false;
+/**
+ * Register the swarm "connection" handler once (not per getRPC call).
+ * This fixes the event listener leak where each getRPC() call added
+ * a new listener, causing duplicate RPC instances on the same stream.
+ */
+function ensureConnectionHandler() {
+    if (connectionHandlerRegistered)
+        return;
+    connectionHandlerRegistered = true;
     const swarm = getSwarm();
-    if (!rpc) {
-        // Need to establish connection first
-        try {
-            logger.info(`🔗 Establishing RPC connection to topic: ${topic}, peer: ${publicKey}, timeout: ${timeout}ms`);
-            const connectionPromise = (async () => {
-                const topicBuffer = Buffer.from(topic, "hex");
-                // const discovery =
-                swarm.join(topicBuffer, {
-                    server: false,
-                    client: true,
-                });
-                await swarm.flush();
-                logger.info(`✅ Connected to topic: ${topic}`);
-                logger.debug(`📊 Active RPC connections: ${activeRPCs.size}`);
-                // Check again if we now have an RPC instance for the target peer
-                rpc = activeRPCs.get(publicKey);
-                if (!rpc) {
-                    logger.error(`❌ No RPC instance found for peer ${publicKey}`);
-                    logger.debug(`📊 Available RPC connections:`, Array.from(activeRPCs.keys()));
-                    throw new DelegateConnectionFailedError(`Could not establish RPC connection to peer ${publicKey} on topic ${topic}`);
-                }
-                else {
-                    logger.debug(`✅ RPC instance found for peer ${publicKey}`);
-                }
-            })();
-            await withTimeout(connectionPromise, timeout);
-        }
-        catch (error) {
-            logger.error("Failed to establish RPC connection:", error);
-            throw new DelegateConnectionFailedError(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`, error);
-        }
-    }
-    return rpc;
-}
-// Create an RPC instance for a specific HyperSwarm peer
-export async function getRPC(topic, publicKey, options = {}) {
-    const swarm = getSwarm();
-    // Close existing connection if forceNewConnection is true
-    if (options.forceNewConnection) {
-        closeConnection(publicKey);
-    }
-    // Set up connection tracking
     swarm.on("connection", (conn) => {
         const peerPubkey = conn.remotePublicKey?.toString("hex");
         if (!peerPubkey)
             return;
-        logger.debug(`🍺 New peer connection established: ${peerPubkey}`);
+        logger.info(`🍺 New peer connection established: ${peerPubkey}`);
         // Create RPC instance for this connection (as client)
         const rpc = new RPC(conn, () => {
             // No-op handler since we're only sending requests, not receiving them
@@ -87,5 +43,129 @@ export async function getRPC(topic, publicKey, options = {}) {
             activeConnections.delete(peerPubkey);
         });
     });
+}
+async function closeConnection(publicKey) {
+    const existingConnection = activeConnections.get(publicKey);
+    if (existingConnection) {
+        logger.info(`🔌 Closing existing connection for peer: ${publicKey}`);
+        // Wait for the close event before returning so Hyperswarm's internal
+        // _allConnections is cleaned up before we attempt to rejoin/flush.
+        await new Promise((resolve) => {
+            const timeout = setTimeout(resolve, 5000);
+            existingConnection.on("close", () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            existingConnection.destroy();
+        });
+        activeConnections.delete(publicKey);
+        activeRPCs.delete(publicKey);
+    }
+}
+// Establish RPC connection to a peer if not already connected
+async function ensureRPCConnection(topic, publicKey, timeout) {
+    // Check if we already have an RPC instance for this peer
+    const existingRpc = activeRPCs.get(publicKey);
+    if (existingRpc) {
+        return existingRpc;
+    }
+    const swarm = getSwarm();
+    // Track the listener so we can clean it up on timeout
+    let onConnection = () => { };
+    try {
+        logger.info(`🔗 Establishing RPC connection to topic: ${topic}, peer: ${publicKey}, timeout: ${timeout}ms`);
+        const connectionPromise = new Promise((resolve, reject) => {
+            const topicBuffer = Buffer.from(topic, "hex");
+            swarm.join(topicBuffer, {
+                server: false,
+                client: true,
+            });
+            // Wait for the specific peer's connection event instead of just
+            // checking after flush. This handles the case where flush resolves
+            // (discovery done) but the P2P connection is still being established
+            // via holepunching or relays.
+            onConnection = (conn) => {
+                const peerPubkey = conn.remotePublicKey?.toString("hex");
+                if (peerPubkey === publicKey) {
+                    swarm.removeListener("connection", onConnection);
+                    // The global handler (ensureConnectionHandler) will create the RPC
+                    // and store it in activeRPCs. Give it a tick to run first.
+                    const rpc = activeRPCs.get(publicKey);
+                    if (rpc) {
+                        resolve(rpc);
+                    }
+                    else {
+                        // Global handler runs synchronously before us in the same event,
+                        // so this shouldn't happen, but handle it just in case
+                        setTimeout(() => {
+                            const delayedRpc = activeRPCs.get(publicKey);
+                            if (delayedRpc) {
+                                resolve(delayedRpc);
+                            }
+                            else {
+                                reject(new DelegateConnectionFailedError(`Connection established but RPC not created for peer ${publicKey}`));
+                            }
+                        }, 100);
+                    }
+                }
+            };
+            swarm.on("connection", onConnection);
+            // Also flush to trigger discovery. After flush, check if the connection
+            // was already established (the global handler may have caught it).
+            void swarm.flush().then(() => {
+                logger.info(`✅ Flush completed for topic: ${topic}`);
+                logger.debug(`📊 Active RPC connections: ${activeRPCs.size}`);
+                const rpc = activeRPCs.get(publicKey);
+                if (rpc) {
+                    swarm.removeListener("connection", onConnection);
+                    resolve(rpc);
+                }
+                // If not connected after flush, the onConnection listener keeps
+                // waiting until the timeout from withTimeout kicks in.
+                // Hyperswarm may still establish the connection via retries/relays.
+                logger.debug(`⏳ Peer not connected after flush, waiting for connection event...`);
+            });
+        });
+        return await withTimeout(connectionPromise, timeout);
+    }
+    catch (error) {
+        // Clean up the per-request connection listener
+        swarm.removeListener("connection", onConnection);
+        // Remove stale connection so next attempt creates a fresh one
+        // instead of reusing a dead RPC
+        logger.info(`🗑️ Removing stale connection for peer: ${publicKey} after failed RPC attempt`);
+        activeRPCs.delete(publicKey);
+        const conn = activeConnections.get(publicKey);
+        if (conn) {
+            conn.destroy();
+            activeConnections.delete(publicKey);
+        }
+        logger.error("Failed to establish RPC connection:", error);
+        throw new DelegateConnectionFailedError(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+}
+// Create an RPC instance for a specific HyperSwarm peer
+export async function getRPC(topic, publicKey, options = {}) {
+    // Ensure the global connection handler is registered (once)
+    ensureConnectionHandler();
+    // Close existing connection if forceNewConnection is true
+    // Await the close to avoid racing with the subsequent join/flush
+    if (options.forceNewConnection) {
+        await closeConnection(publicKey);
+    }
     return await ensureRPCConnection(topic, publicKey, options.timeout);
 }
+/**
+ * Remove a stale RPC connection for a peer.
+ * Called when a delegation request fails (e.g., timeout) so the next
+ * attempt creates a fresh connection instead of reusing a dead RPC.
+ */
+export function cleanupStaleConnection(publicKey) {
+    logger.info(`🗑️ Removing stale connection for peer: ${publicKey} after failed delegation`);
+    activeRPCs.delete(publicKey);
+    const conn = activeConnections.get(publicKey);
+    if (conn) {
+        conn.destroy();
+        activeConnections.delete(publicKey);
+    }
+}

package/dist/server/bare/{addons/llamacpp-embedding/handlers → ops}/embed.d.ts

@@ -1,4 +1,4 @@
-import { type EmbedParams } from "../../../../../schemas/index";
+import { type EmbedParams } from "../../../schemas/index";
 export declare function embed(params: {
     modelId: string;
     text: string;

package/dist/server/bare/{addons/llamacpp-embedding/handlers → ops}/embed.js

@@ -1,6 +1,6 @@
-import { getModel } from "../../../registry/model-registry.js";
-import { embedParamsSchema } from "../../../../../schemas/index.js";
-import { EmbedNoEmbeddingsError, EmbedFailedError, } from "../../../../../utils/errors-server.js";
+import { getModel } from "../registry/model-registry.js";
+import { embedParamsSchema } from "../../../schemas/index.js";
+import { EmbedNoEmbeddingsError, EmbedFailedError, } from "../../../utils/errors-server.js";
 export async function embed(params) {
     const { modelId, text } = embedParamsSchema.parse(params);
     const model = getModel(modelId);

package/dist/server/bare/{addons/llamacpp-completion → ops}/kv-cache-utils.js

@@ -1,8 +1,8 @@
 import crypto from "bare-crypto";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
-import { getKVCacheDir } from "../../../utils/index.js";
-import { getServerLogger } from "../../../../logging/index.js";
+import { getKVCacheDir, validateAndJoinPath } from "../../utils/index.js";
+import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
 // In-memory registry tracks caches initialized this session (addon defers disk writes)
 const initializedCaches = new Set();
@@ -57,8 +57,8 @@ export function generateCacheKey(messages) {
 }
 export async function getCacheFilePath(modelId, configHash, cacheKey) {
     const cacheDir = getKVCacheDir();
-    const sessionCacheDir = path.join(cacheDir, cacheKey);
-    const modelCacheDir = path.join(sessionCacheDir, modelId);
+    const sessionCacheDir = validateAndJoinPath(cacheDir, cacheKey);
+    const modelCacheDir = validateAndJoinPath(sessionCacheDir, modelId);
     try {
         await fsPromises.mkdir(sessionCacheDir, { recursive: true });
         await fsPromises.mkdir(modelCacheDir, { recursive: true });
@@ -126,9 +126,9 @@ export async function deleteCache(options) {
         }
     }
     else if ("kvCacheKey" in options) {
-        const kvCacheDir = path.join(cacheDir, options.kvCacheKey);
+        const kvCacheDir = validateAndJoinPath(cacheDir, options.kvCacheKey);
         if (options.modelId) {
-            const modelCacheDir = path.join(kvCacheDir, options.modelId);
+            const modelCacheDir = validateAndJoinPath(kvCacheDir, options.modelId);
             try {
                 await fsPromises.rm(modelCacheDir, { recursive: true });
             }

package/dist/server/bare/{addons → ops}/load-model.js

@@ -1,21 +1,18 @@
-import { loadModelServerParamsSchema, ModelType, } from "../../../schemas/index.js";
-import { createLlmModel } from "./llamacpp-completion/index.js";
-import { createEmbeddingsModel } from "./llamacpp-embedding/index.js";
-import { createNmtModel } from "./nmtcpp-translation/index.js";
-import { createTtsModel } from "./onnx-tts/index.js";
-import { createWhisperModel } from "./whispercpp-transcription/index.js";
-import { createOCRModel } from "./onnx-ocr/index.js";
+import { loadModelServerParamsSchema, ModelType, normalizeModelType, } from "../../../schemas/index.js";
 import { isModelLoaded, registerModel, } from "../registry/model-registry.js";
 import { startLogBuffering, stopLogBufferingWithTimeout, } from "../registry/logging-stream-registry.js";
 import { detectShardedModel, generateShardFilenames, validateShardedModelCache, } from "../../utils/index.js";
-import { ESpeakDataPathRequiredError, ModelLoadFailedError, UnknownModelTypeError, ModelFileNotFoundError, ModelFileNotFoundInDirError, ModelFileLocateFailedError, } from "../../../utils/errors-server.js";
+import { ModelLoadFailedError, PluginNotFoundError, ModelFileNotFoundError, ModelFileNotFoundInDirError, ModelFileLocateFailedError, } from "../../../utils/errors-server.js";
+import { getPlugin } from "../../plugins/index.js";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
 export async function loadModel(params) {
-    const { modelId, modelPath, options, projectionModelPath, vadModelPath, ttsConfigModelPath, eSpeakDataPath, detectorModelPath, modelName, } = loadModelServerParamsSchema.parse(params);
-    const { modelConfig, modelType } = options;
+    const { modelId, modelPath, options, projectionModelPath, vadModelPath, detectorModelPath, modelName, } = loadModelServerParamsSchema.parse(params);
+    const { modelConfig, modelType: rawModelType } = options;
+    // Normalize modelType to canonical form (handles aliases and custom types)
+    const modelType = normalizeModelType(rawModelType);
     // Check if model is already loaded
     if (isModelLoaded(modelId)) {
         logger.info(`${modelType} model ${modelId} is already loaded`);
@@ -34,8 +31,9 @@ export async function loadModel(params) {
             throw new ModelFileNotFoundError(`Missing shards or ${shardInfo.baseFilename}.tensors.txt. Expected ${numberedShards.length} shard files + tensors.txt in ${shardDir}`);
         }
     }
-    else {
+    else if (modelType !== ModelType.onnxTts) {
         // For non-sharded models, validate single file exists
+        // Skip for TTS - it uses multiple paths from modelConfig (resolved by plugin.resolveConfig)
         try {
             const modelDir = path.dirname(modelPath);
             const modelFile = path.basename(modelPath);
@@ -49,37 +47,29 @@ export async function loadModel(params) {
             throw new ModelFileLocateFailedError(modelType, modelPath, error);
         }
     }
-    let result;
-    switch (modelType) {
-        case ModelType.llamacppCompletion:
-            result = createLlmModel(modelId, modelPath, modelConfig, projectionModelPath);
-            break;
-        case ModelType.whispercppTranscription:
-            result = createWhisperModel(modelId, modelPath, modelConfig, vadModelPath);
-            break;
-        case ModelType.llamacppEmbedding:
-            result = createEmbeddingsModel(modelId, modelPath, modelConfig);
-            break;
-        case ModelType.nmtcppTranslation:
-            result = createNmtModel(modelId, modelPath, modelConfig);
-            break;
-        case ModelType.onnxTts:
-            if (!eSpeakDataPath) {
-                throw new ESpeakDataPathRequiredError();
-            }
-            result = createTtsModel(modelId, modelPath, modelConfig, ttsConfigModelPath, eSpeakDataPath);
-            break;
-        case ModelType.onnxOcr:
-            if (!detectorModelPath) {
-                throw new ModelLoadFailedError("Detector model required for OCR. Use a hyperdrive source or provide detectorModelSrc");
-            }
-            // modelPath is the recognizer, detectorModelPath is auto-derived
-            result = createOCRModel(modelId, detectorModelPath, modelPath, modelConfig);
-            break;
-        default:
-            // Should never happen - normalizeModelType validates input
-            throw new UnknownModelTypeError(modelType);
+    if (modelType === ModelType.onnxOcr && !detectorModelPath) {
+        throw new ModelLoadFailedError("Detector model required for OCR. Use a hyperdrive source or provide detectorModelSrc");
     }
+    const plugin = getPlugin(modelType);
+    if (!plugin) {
+        throw new PluginNotFoundError(modelType);
+    }
+    // Build artifacts map for plugin
+    // Note: TTS paths are in modelConfig (resolved by plugin.resolveConfig), not artifacts
+    const artifacts = {};
+    if (projectionModelPath)
+        artifacts["projectionModelPath"] = projectionModelPath;
+    if (vadModelPath)
+        artifacts["vadModelPath"] = vadModelPath;
+    if (detectorModelPath)
+        artifacts["detectorModelPath"] = detectorModelPath;
+    const result = plugin.createModel({
+        modelId,
+        modelPath,
+        modelConfig: modelConfig,
+        modelName,
+        artifacts: Object.keys(artifacts).length > 0 ? artifacts : undefined,
+    });
     logger.info(`${modelType}: Loading model ${modelId}...`);
     startLogBuffering(modelId);
     await result.model.load(false);
@@ -89,7 +79,7 @@ export async function loadModel(params) {
         model: result.model,
         path: modelPath,
         config: modelConfig,
-        modelType,
+        modelType: modelType,
         name: modelName,
         loader: result.loader,
     });

package/dist/server/bare/{addons/nmtcpp-translation/handlers → ops}/translate.d.ts

@@ -1,3 +1,3 @@
-import { type TranslateParams, type TranslationStats } from "../../../../../schemas/index";
+import { type TranslateParams, type TranslationStats } from "../../../schemas/index";
 export declare function translate(params: TranslateParams): AsyncGenerator<string, TranslationStats | undefined, unknown>;
 //# sourceMappingURL=translate.d.ts.map

package/dist/server/bare/{addons/nmtcpp-translation/handlers → ops}/translate.js

@@ -1,5 +1,5 @@
-import { getModel } from "../../../registry/model-registry.js";
-import { translateServerParamsSchema, normalizeModelType, ModelType, } from "../../../../../schemas/index.js";
+import { getModel } from "../registry/model-registry.js";
+import { translateServerParamsSchema, normalizeModelType, ModelType, } from "../../../schemas/index.js";
 import { getLangName } from "@qvac/langdetect-text";
 function getLanguage(code) {
     if (!code)
@@ -26,10 +26,11 @@ export async function* translate(params) {
         // Use runBatch for batch processing
         const translations = await model.runBatch(text);
         // Yield each translation with a newline separator
-        for (const translation of translations) {
+        for (let i = 0; i < translations.length; i++) {
+            const translation = translations[i];
             processedTokens++;
             yield translation;
-            if (translations.indexOf(translation) < translations.length - 1) {
+            if (i < translations.length - 1) {
                 yield "\n";
             }
         }

package/dist/server/bare/plugins/index.d.ts

@@ -0,0 +1,7 @@
+export { llmPlugin } from "./llamacpp-completion/plugin";
+export { embeddingsPlugin } from "./llamacpp-embedding/plugin";
+export { whisperPlugin } from "./whispercpp-transcription/plugin";
+export { nmtPlugin } from "./nmtcpp-translation/plugin";
+export { ttsPlugin } from "./onnx-tts/plugin";
+export { ocrPlugin } from "./onnx-ocr/plugin";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/bare/plugins/index.js

@@ -0,0 +1,6 @@
+export { llmPlugin } from "./llamacpp-completion/plugin.js";
+export { embeddingsPlugin } from "./llamacpp-embedding/plugin.js";
+export { whisperPlugin } from "./whispercpp-transcription/plugin.js";
+export { nmtPlugin } from "./nmtcpp-translation/plugin.js";
+export { ttsPlugin } from "./onnx-tts/plugin.js";
+export { ocrPlugin } from "./onnx-ocr/plugin.js";

package/dist/server/bare/{addons/llamacpp-completion → plugins/llamacpp-completion/ops}/cache-logger.js

@@ -1,4 +1,4 @@
-import { getServerLogger } from "../../../../logging/index.js";
+import { getServerLogger } from "../../../../../logging/index.js";
 const logger = getServerLogger();
 function formatMessages(messages) {
     return messages

package/dist/server/bare/{addons/llamacpp-completion/handlers → plugins/llamacpp-completion/ops}/completion-stream.d.ts

@@ -1,4 +1,4 @@
-import { type CompletionParams, type CompletionStats, type Tool, type ToolCall, type ToolCallEvent } from "../../../../../schemas/index";
+import type { CompletionParams, CompletionStats, Tool, ToolCall, ToolCallEvent } from "../../../../../schemas/index";
 export declare function completion(params: CompletionParams & {
     tools?: Tool[];
 }): AsyncGenerator<{

package/dist/server/bare/{addons/llamacpp-completion/handlers → plugins/llamacpp-completion/ops}/completion-stream.js

@@ -1,6 +1,5 @@
-import {} from "../../../../../schemas/index.js";
-import { logCacheDisabled, logCacheInit, logCacheSave, logCacheStatus, logMessagesToAddon, } from "../cache-logger.js";
-import { customCacheExists, extractSystemPrompt, findMatchingCache, generateConfigHash, getCacheFilePath, getCurrentCacheInfo, markCacheInitialized, renameCacheFile, } from "../kv-cache-utils.js";
+import { logCacheDisabled, logCacheInit, logCacheSave, logCacheStatus, logMessagesToAddon, } from "./cache-logger.js";
+import { customCacheExists, extractSystemPrompt, findMatchingCache, generateConfigHash, getCacheFilePath, getCurrentCacheInfo, markCacheInitialized, renameCacheFile, } from "../../../ops/kv-cache-utils.js";
 import { getModel, getModelConfig, } from "../../../registry/model-registry.js";
 import { checkForToolEvents, insertToolsIntoHistory, setupToolGrammar, } from "../../../../utils/tool-integration.js";
 import { parseToolCalls } from "../../../../utils/tool-parser.js";