@qvac/sdk 0.14.1 → 0.16.0

package/dist/server/bare/plugins/tts-ggml/plugin.js

@@ -1,11 +1,11 @@
-import ttsAddonLogging from "@qvac/tts-ggml/addonLogging.js";
-import TTSGgml from "@qvac/tts-ggml";
-import { definePlugin, defineHandler, defineDuplexHandler, ttsRequestSchema, ttsResponseSchema, textToSpeechStreamRequestSchema, textToSpeechStreamResponseSchema, ModelType, ttsConfigSchema, ADDON_TTS, LEGACY_TTS_ONNX_MODEL_CONFIG_FIELDS, } from "../../../../schemas/index.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { TtsArtifactsRequiredError, LegacyTtsModelDeprecatedError, } from "../../../../utils/errors-server.js";
-import { textToSpeech } from "./ops/text-to-speech.js";
-import { textToSpeechStream } from "./ops/text-to-speech-stream.js";
-import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
+import ttsAddonLogging from '@qvac/tts-ggml/addonLogging.js';
+import TTSGgml from '@qvac/tts-ggml';
+import { definePlugin, defineHandler, defineDuplexHandler, ttsRequestSchema, ttsResponseSchema, textToSpeechStreamRequestSchema, textToSpeechStreamResponseSchema, ModelType, ttsConfigSchema, ADDON_TTS, LEGACY_TTS_ONNX_MODEL_CONFIG_FIELDS } from '../../../../schemas/index.js';
+import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
+import { TtsArtifactsRequiredError, LegacyTtsModelDeprecatedError } from '../../../../utils/errors-server.js';
+import { textToSpeech } from './ops/text-to-speech.js';
+import { textToSpeechStream } from './ops/text-to-speech-stream.js';
+import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
 function rejectLegacyOnnxFields(cfg) {
     const record = cfg;
     const legacyFields = LEGACY_TTS_ONNX_MODEL_CONFIG_FIELDS.filter((name) => record[name] !== undefined);
@@ -13,33 +13,72 @@ function rejectLegacyOnnxFields(cfg) {
         throw new LegacyTtsModelDeprecatedError(legacyFields);
     }
 }
+function dirname(path) {
+    const normalized = path.replace(/\\/g, '/');
+    const index = normalized.lastIndexOf('/');
+    if (index <= 0)
+        return index === 0 ? '/' : '.';
+    return path.slice(0, index);
+}
+// Resolve the optional LavaSR enhancer/denoiser GGUFs shared by both engines.
+async function resolveLavasrArtifacts(lavasrEnhancerModelSrc, lavasrDenoiserModelSrc, ctx) {
+    const resolve = ctx.resolveModelPath;
+    const [lavasrEnhancerPath, lavasrDenoiserPath] = await Promise.all([
+        lavasrEnhancerModelSrc ? resolve(lavasrEnhancerModelSrc) : Promise.resolve(undefined),
+        lavasrDenoiserModelSrc ? resolve(lavasrDenoiserModelSrc) : Promise.resolve(undefined)
+    ]);
+    return {
+        ...(lavasrEnhancerPath ? { lavasrEnhancerPath } : {}),
+        ...(lavasrDenoiserPath ? { lavasrDenoiserPath } : {})
+    };
+}
 async function resolveChatterboxConfig(config, ctx) {
     rejectLegacyOnnxFields(config);
-    const { s3genModelSrc, referenceAudioSrc, ...runtime } = config;
+    const { s3genModelSrc, referenceAudioSrc, mecabDictSrc, cangjieTsvSrc, lavasrEnhancerModelSrc, lavasrDenoiserModelSrc, ...runtime } = config;
     if (!s3genModelSrc) {
         throw new TtsArtifactsRequiredError();
     }
     const resolve = ctx.resolveModelPath;
-    const [s3genPath, referenceAudioPath] = await Promise.all([
+    const [s3genPath, referenceAudioPath, mecabDictFilePath, cangjieTsvPath, lavasrArtifacts] = await Promise.all([
         resolve(s3genModelSrc),
         referenceAudioSrc ? resolve(referenceAudioSrc) : Promise.resolve(undefined),
+        mecabDictSrc ? resolve(mecabDictSrc) : Promise.resolve(undefined),
+        cangjieTsvSrc ? resolve(cangjieTsvSrc) : Promise.resolve(undefined),
+        resolveLavasrArtifacts(lavasrEnhancerModelSrc, lavasrDenoiserModelSrc, ctx)
     ]);
     return {
         config: runtime,
         artifacts: {
             s3genPath,
             ...(referenceAudioPath ? { referenceAudioPath } : {}),
-        },
+            ...(mecabDictFilePath ? { mecabDictPath: dirname(mecabDictFilePath) } : {}),
+            ...(cangjieTsvPath ? { cangjieTsvPath } : {}),
+            ...lavasrArtifacts
+        }
     };
 }
-function resolveSupertonicConfig(config) {
+async function resolveSupertonicConfig(config, ctx) {
     rejectLegacyOnnxFields(config);
-    return Promise.resolve({ config });
+    const { lavasrEnhancerModelSrc, lavasrDenoiserModelSrc, ...runtime } = config;
+    const lavasrArtifacts = await resolveLavasrArtifacts(lavasrEnhancerModelSrc, lavasrDenoiserModelSrc, ctx);
+    return { config: runtime, artifacts: lavasrArtifacts };
+}
+// Build the optional LavaSR `files` entries from resolved artifacts. Supplying
+// a path is what enables the stage in @qvac/tts-ggml — there is no on/off flag.
+function lavasrFiles(artifacts) {
+    const lavasrEnhancer = artifacts['lavasrEnhancerPath'];
+    const lavasrDenoiser = artifacts['lavasrDenoiserPath'];
+    return {
+        ...(lavasrEnhancer ? { lavasrEnhancer } : {}),
+        ...(lavasrDenoiser ? { lavasrDenoiser } : {})
+    };
 }
 function createChatterboxModel(modelId, config, params, artifacts) {
     const t3Model = params.modelPath;
-    const s3genModel = artifacts["s3genPath"];
-    const referenceAudioPath = artifacts["referenceAudioPath"];
+    const s3genModel = artifacts['s3genPath'];
+    const referenceAudioPath = artifacts['referenceAudioPath'];
+    const mecabDictPath = artifacts['mecabDictPath'];
+    const cangjieTsvPath = artifacts['cangjieTsvPath'];
     if (!t3Model || !s3genModel) {
         throw new TtsArtifactsRequiredError();
     }
@@ -47,7 +86,13 @@ function createChatterboxModel(modelId, config, params, artifacts) {
     registerAddonLogger(modelId, ModelType.ttsGgml, logger);
     const model = new TTSGgml({
         engine: TTSGgml.ENGINE_CHATTERBOX,
-        files: { t3Model, s3genModel },
+        files: {
+            t3Model,
+            s3genModel,
+            ...(mecabDictPath ? { mecabDictPath } : {}),
+            ...(cangjieTsvPath ? { cangjieTsvPath } : {}),
+            ...lavasrFiles(artifacts)
+        },
         ...(referenceAudioPath ? { referenceAudio: referenceAudioPath } : {}),
         ...(config.streamChunkTokens !== undefined
             ? { streamChunkTokens: config.streamChunkTokens }
@@ -56,22 +101,21 @@ function createChatterboxModel(modelId, config, params, artifacts) {
             ? { streamFirstChunkTokens: config.streamFirstChunkTokens }
             : {}),
         ...(config.cfmSteps !== undefined ? { cfmSteps: config.cfmSteps } : {}),
+        ...(config.cfgRate !== undefined ? { cfgRate: config.cfgRate } : {}),
         ...(config.threads !== undefined ? { threads: config.threads } : {}),
-        ...(config.nGpuLayers !== undefined
-            ? { nGpuLayers: config.nGpuLayers }
-            : {}),
+        ...(config.nGpuLayers !== undefined ? { nGpuLayers: config.nGpuLayers } : {}),
         ...(config.seed !== undefined ? { seed: config.seed } : {}),
         config: {
-            language: config.language ?? "en",
-            ...(config.useGPU !== undefined ? { useGPU: config.useGPU } : {}),
+            language: config.language ?? 'en',
+            ...(config.useGPU !== undefined ? { useGPU: config.useGPU } : {})
         },
         logger,
         opts: { stats: true },
-        exclusiveRun: true,
+        exclusiveRun: true
     });
     return { model };
 }
-function createSupertonicModel(modelId, config, params) {
+function createSupertonicModel(modelId, config, params, artifacts) {
     const supertonicModel = params.modelPath;
     if (!supertonicModel) {
         throw new TtsArtifactsRequiredError();
@@ -80,40 +124,44 @@ function createSupertonicModel(modelId, config, params) {
     registerAddonLogger(modelId, ModelType.ttsGgml, logger);
     const model = new TTSGgml({
         engine: TTSGgml.ENGINE_SUPERTONIC,
-        files: { supertonicModel },
-        voice: config.voice ?? "F1",
+        files: { supertonicModel, ...lavasrFiles(artifacts) },
+        voice: config.voice ?? 'F1',
         ...(config.ttsSpeed !== undefined ? { speed: config.ttsSpeed } : {}),
         ...(config.ttsNumInferenceSteps !== undefined
             ? { numInferenceSteps: config.ttsNumInferenceSteps }
             : {}),
         config: {
-            language: config.language ?? "en",
+            language: config.language ?? 'en',
             useGPU: config.useGPU ?? false,
+            ...(config.outputSampleRate !== undefined
+                ? { outputSampleRate: config.outputSampleRate }
+                : {}),
+            ...(config.vulkanCacheDir !== undefined ? { vulkanCacheDir: config.vulkanCacheDir } : {})
         },
         logger,
         opts: { stats: true },
-        exclusiveRun: true,
+        exclusiveRun: true
     });
     return { model };
 }
 export const ttsPlugin = definePlugin({
     modelType: ModelType.ttsGgml,
-    displayName: "TTS (GGML)",
+    displayName: 'TTS (GGML)',
     addonPackage: ADDON_TTS,
     loadConfigSchema: ttsConfigSchema,
     async resolveConfig(cfg, ctx) {
         const { ttsEngine } = cfg;
         // Same default as the former onnx-tts plugin: omitting `ttsEngine` → Chatterbox.
-        if (ttsEngine === "supertonic") {
-            return resolveSupertonicConfig(cfg);
+        if (ttsEngine === 'supertonic') {
+            return resolveSupertonicConfig(cfg, ctx);
         }
         return resolveChatterboxConfig(cfg, ctx);
     },
     createModel(params) {
         const config = (params.modelConfig ?? {});
         const artifacts = params.artifacts ?? {};
-        if (config.ttsEngine === "supertonic") {
-            return createSupertonicModel(params.modelId, config, params);
+        if (config.ttsEngine === 'supertonic') {
+            return createSupertonicModel(params.modelId, config, params, artifacts);
         }
         return createChatterboxModel(params.modelId, config, params, artifacts);
     },
@@ -122,80 +170,80 @@ export const ttsPlugin = definePlugin({
             requestSchema: ttsRequestSchema,
             responseSchema: ttsResponseSchema,
             streaming: true,
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: true },
             handler: async function* (request) {
                 const stream = textToSpeech(request);
                 try {
                     let result = await stream.next();
                     while (!result.done) {
                         yield {
-                            type: "textToSpeech",
+                            type: 'textToSpeech',
                             buffer: result.value.buffer,
                             done: false,
                             ...(result.value.chunkIndex !== undefined
                                 ? { chunkIndex: result.value.chunkIndex }
                                 : {}),
-                            ...(typeof result.value.sentenceChunk === "string" &&
+                            ...(typeof result.value.sentenceChunk === 'string' &&
                                 result.value.sentenceChunk.length > 0
                                 ? { sentenceChunk: result.value.sentenceChunk }
-                                : {}),
+                                : {})
                         };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
                     yield attachModelExecutionMs({
-                        type: "textToSpeech",
+                        type: 'textToSpeech',
                         buffer: [],
                         done: true,
-                        ...(stats && { stats }),
+                        ...(stats && { stats })
                     }, modelExecutionMs);
                 }
                 finally {
                     await stream.return?.(undefined);
                 }
-            },
+            }
         }),
         textToSpeechStream: defineDuplexHandler({
             requestSchema: textToSpeechStreamRequestSchema,
             responseSchema: textToSpeechStreamResponseSchema,
             streaming: true,
             duplex: true,
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: true },
             handler: async function* (request, inputStream) {
                 const stream = textToSpeechStream(request, inputStream);
                 try {
                     let result = await stream.next();
                     while (!result.done) {
                         yield {
-                            type: "textToSpeechStream",
+                            type: 'textToSpeechStream',
                             buffer: result.value.buffer,
                             done: false,
                             ...(result.value.chunkIndex !== undefined
                                 ? { chunkIndex: result.value.chunkIndex }
                                 : {}),
-                            ...(typeof result.value.sentenceChunk === "string" &&
+                            ...(typeof result.value.sentenceChunk === 'string' &&
                                 result.value.sentenceChunk.length > 0
                                 ? { sentenceChunk: result.value.sentenceChunk }
-                                : {}),
+                                : {})
                         };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
                     yield attachModelExecutionMs({
-                        type: "textToSpeechStream",
+                        type: 'textToSpeechStream',
                         buffer: [],
                         done: true,
-                        ...(stats && { stats }),
+                        ...(stats && { stats })
                     }, modelExecutionMs);
                 }
                 finally {
                     await stream.return?.(undefined);
                 }
-            },
-        }),
+            }
+        })
     },
     logging: {
         module: ttsAddonLogging,
-        namespace: ModelType.ttsGgml,
-    },
+        namespace: ModelType.ttsGgml
+    }
 });

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

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult, type ResolveContext, type WhisperConfig } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type WhisperConfig } from '../../../../schemas/index';
 export declare const whisperPlugin: {
     modelType: "whispercpp-transcription";
     displayName: string;

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

@@ -1,34 +1,34 @@
-import whisperAddonLogging from "@qvac/transcription-whispercpp/addonLogging.js";
-import TranscriptionWhispercpp, {} from "@qvac/transcription-whispercpp";
-import { definePlugin, defineHandler, defineDuplexHandler, transcribeRequestSchema, transcribeResponseSchema, transcribeStreamRequestSchema, transcribeStreamResponseSchema, ModelType, whisperConfigSchema, ADDON_WHISPER, } from "../../../../schemas/index.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { transcribe, transcribeStream } from "../../ops/transcribe.js";
-import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
+import whisperAddonLogging from '@qvac/transcription-whispercpp/addonLogging.js';
+import TranscriptionWhispercpp, {} from '@qvac/transcription-whispercpp';
+import { definePlugin, defineHandler, defineDuplexHandler, transcribeRequestSchema, transcribeResponseSchema, transcribeStreamRequestSchema, transcribeStreamResponseSchema, ModelType, whisperConfigSchema, ADDON_WHISPER } from '../../../../schemas/index.js';
+import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
+import { transcribe, transcribeStream } from '../../ops/transcribe.js';
+import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
 function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
     const logger = createStreamLogger(modelId, ModelType.whispercppTranscription);
     registerAddonLogger(modelId, ModelType.whispercppTranscription, logger);
     const args = {
         files: {
             model: modelPath,
-            ...(vadModelPath && { vadModel: vadModelPath }),
+            ...(vadModelPath && { vadModel: vadModelPath })
         },
         logger,
         opts: {
-            stats: true,
-        },
+            stats: true
+        }
     };
     const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
     const config = {
         whisperConfig: whisperParams,
         ...(contextParams && { contextParams }),
-        ...(miscConfig && { miscConfig }),
+        ...(miscConfig && { miscConfig })
     };
     const model = new TranscriptionWhispercpp(args, config);
     return { model };
 }
 export const whisperPlugin = definePlugin({
     modelType: ModelType.whispercppTranscription,
-    displayName: "Whisper (whisper.cpp)",
+    displayName: 'Whisper (whisper.cpp)',
     addonPackage: ADDON_WHISPER,
     loadConfigSchema: whisperConfigSchema,
     async resolveConfig(cfg, ctx) {
@@ -39,12 +39,12 @@ export const whisperPlugin = definePlugin({
         const vadModelPath = await ctx.resolveModelPath(vadModelSrc);
         return {
             config: whisperConfig,
-            artifacts: { vadModelPath },
+            artifacts: { vadModelPath }
         };
     },
     createModel(params) {
         const whisperConfig = (params.modelConfig ?? {});
-        const { model } = createWhisperModel(params.modelId, params.modelPath, whisperConfig, params.artifacts?.["vadModelPath"]);
+        const { model } = createWhisperModel(params.modelId, params.modelPath, whisperConfig, params.artifacts?.['vadModelPath']);
         return { model };
     },
     handlers: {
@@ -54,7 +54,7 @@ export const whisperPlugin = definePlugin({
             streaming: true,
             // whisper.cpp addon exposes a model-wide hard cancel — compute
             // is interrupted on the currently-running transcription.
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: true },
             handler: async function* (request) {
                 const metadata = request.metadata === true;
                 const stream = metadata
@@ -62,39 +62,39 @@ export const whisperPlugin = definePlugin({
                         modelId: request.modelId,
                         audioChunk: request.audioChunk,
                         prompt: request.prompt,
-                        metadata: true,
+                        metadata: true
                     }, request.requestId)
                     : transcribe({
                         modelId: request.modelId,
                         audioChunk: request.audioChunk,
-                        prompt: request.prompt,
+                        prompt: request.prompt
                     }, request.requestId);
                 try {
                     let result = await stream.next();
                     while (!result.done) {
                         yield metadata
                             ? {
-                                type: "transcribe",
-                                segment: result.value,
+                                type: 'transcribe',
+                                segment: result.value
                             }
                             : {
-                                type: "transcribe",
-                                text: result.value,
+                                type: 'transcribe',
+                                text: result.value
                             };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
                     yield attachModelExecutionMs({
-                        type: "transcribe",
-                        text: "",
+                        type: 'transcribe',
+                        text: '',
                         done: true,
-                        ...(stats && { stats }),
+                        ...(stats && { stats })
                     }, modelExecutionMs);
                 }
                 finally {
                     await stream.return?.(undefined);
                 }
-            },
+            }
         }),
         transcribeStream: defineDuplexHandler({
             requestSchema: transcribeStreamRequestSchema,
@@ -103,50 +103,50 @@ export const whisperPlugin = definePlugin({
             duplex: true,
             // Same model-wide hard cancel surface as `transcribe` — both
             // route through the whisper.cpp addon.
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: true },
             handler: async function* (request, inputStream) {
                 const streamOpts = {
                     ...(request.emitVadEvents !== undefined && {
-                        emitVadEvents: request.emitVadEvents,
+                        emitVadEvents: request.emitVadEvents
                     }),
                     ...(request.endOfTurnSilenceMs !== undefined && {
-                        endOfTurnSilenceMs: request.endOfTurnSilenceMs,
+                        endOfTurnSilenceMs: request.endOfTurnSilenceMs
                     }),
                     ...(request.vadRunIntervalMs !== undefined && {
-                        vadRunIntervalMs: request.vadRunIntervalMs,
-                    }),
+                        vadRunIntervalMs: request.vadRunIntervalMs
+                    })
                 };
                 const metadata = request.metadata === true;
                 const iterator = metadata
                     ? transcribeStream(request.modelId, inputStream, request.prompt, true, streamOpts, request.requestId)
                     : transcribeStream(request.modelId, inputStream, request.prompt, false, streamOpts, request.requestId);
                 for await (const value of iterator) {
-                    if (typeof value === "object" && value !== null && "type" in value) {
-                        if (value.type === "vad") {
+                    if (typeof value === 'object' && value !== null && 'type' in value) {
+                        if (value.type === 'vad') {
                             yield {
-                                type: "transcribeStream",
+                                type: 'transcribeStream',
                                 vad: {
                                     speaking: value.speaking,
-                                    probability: value.probability,
-                                },
+                                    probability: value.probability
+                                }
                             };
                             continue;
                         }
-                        if (value.type === "endOfTurn") {
+                        if (value.type === 'endOfTurn') {
                             // Whisper addon emits legacy `{ type, silenceDurationMs }` frames
                             // without `source`. Parakeet must never surface here.
-                            if (value.source === "parakeet") {
+                            if (value.source === 'parakeet') {
                                 continue;
                             }
-                            if (typeof value.silenceDurationMs !== "number") {
+                            if (typeof value.silenceDurationMs !== 'number') {
                                 continue;
                             }
                             yield {
-                                type: "transcribeStream",
+                                type: 'transcribeStream',
                                 endOfTurn: {
-                                    source: "whisper",
-                                    silenceDurationMs: value.silenceDurationMs,
-                                },
+                                    source: 'whisper',
+                                    silenceDurationMs: value.silenceDurationMs
+                                }
                             };
                             continue;
                         }
@@ -154,24 +154,24 @@ export const whisperPlugin = definePlugin({
                     }
                     yield metadata
                         ? {
-                            type: "transcribeStream",
-                            segment: value,
+                            type: 'transcribeStream',
+                            segment: value
                         }
                         : {
-                            type: "transcribeStream",
-                            text: value,
+                            type: 'transcribeStream',
+                            text: value
                         };
                 }
                 yield {
-                    type: "transcribeStream",
-                    text: "",
-                    done: true,
+                    type: 'transcribeStream',
+                    text: '',
+                    done: true
                 };
-            },
-        }),
+            }
+        })
     },
     logging: {
         module: whisperAddonLogging,
-        namespace: ModelType.whispercppTranscription,
-    },
+        namespace: ModelType.whispercppTranscription
+    }
 });

package/dist/server/bare/rag-hyperdb/handlers/chunk.d.ts

@@ -1,3 +1,3 @@
-import { type RagChunkParams } from "../../../../schemas/index";
+import { type RagChunkParams } from '../../../../schemas/index';
 export declare function chunk(params: RagChunkParams): Promise<import("@qvac/rag").Doc[]>;
 //# sourceMappingURL=chunk.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/chunk.js

@@ -1,5 +1,5 @@
-import { LLMChunkAdapter } from "@qvac/rag";
-import { ragChunkParamsSchema } from "../../../../schemas/index.js";
+import { LLMChunkAdapter } from '@qvac/rag';
+import { ragChunkParamsSchema } from '../../../../schemas/index.js';
 export async function chunk(params) {
     const { documents, chunkOpts } = ragChunkParamsSchema.parse(params);
     const chunker = new LLMChunkAdapter(chunkOpts);

package/dist/server/bare/rag-hyperdb/handlers/close-workspace.d.ts

@@ -1,3 +1,3 @@
-import { type RagCloseWorkspaceParams } from "../../../../schemas/index";
+import { type RagCloseWorkspaceParams } from '../../../../schemas/index';
 export declare function closeWorkspace(params: RagCloseWorkspaceParams): Promise<void>;
 //# sourceMappingURL=close-workspace.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/close-workspace.js

@@ -1,5 +1,5 @@
-import { closeRagInstance, deleteWorkspace, DEFAULT_WORKSPACE, } from "../rag-workspace-manager.js";
-import { ragCloseWorkspaceParamsSchema, } from "../../../../schemas/index.js";
+import { closeRagInstance, deleteWorkspace, DEFAULT_WORKSPACE } from '../rag-workspace-manager.js';
+import { ragCloseWorkspaceParamsSchema } from '../../../../schemas/index.js';
 export async function closeWorkspace(params) {
     const { workspace, deleteOnClose } = ragCloseWorkspaceParamsSchema.parse(params);
     await closeRagInstance(workspace);

package/dist/server/bare/rag-hyperdb/handlers/delete-embeddings.d.ts

@@ -1,3 +1,3 @@
-import { type RagDeleteEmbeddingsParams } from "../../../../schemas/index";
+import { type RagDeleteEmbeddingsParams } from '../../../../schemas/index';
 export declare function deleteEmbeddings(params: RagDeleteEmbeddingsParams): Promise<void>;
 //# sourceMappingURL=delete-embeddings.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/delete-embeddings.js

@@ -1,10 +1,10 @@
-import { getRagDbAdapter, hasRagWorkspaceStorage, } from "../rag-workspace-manager.js";
-import { ragDeleteEmbeddingsParamsSchema, } from "../../../../schemas/index.js";
-import { RAGDeleteFailedError } from "../../../../utils/errors-server.js";
+import { getRagDbAdapter, hasRagWorkspaceStorage } from '../rag-workspace-manager.js';
+import { ragDeleteEmbeddingsParamsSchema } from '../../../../schemas/index.js';
+import { RAGDeleteFailedError } from '../../../../utils/errors-server.js';
 export async function deleteEmbeddings(params) {
     const { ids, workspace } = ragDeleteEmbeddingsParamsSchema.parse(params);
     if (!hasRagWorkspaceStorage(workspace)) {
-        throw new RAGDeleteFailedError("workspace is not initialized");
+        throw new RAGDeleteFailedError('workspace is not initialized');
     }
     const dbAdapter = await getRagDbAdapter(workspace);
     await dbAdapter.deleteEmbeddings(ids);

package/dist/server/bare/rag-hyperdb/handlers/delete-workspace.d.ts

@@ -1,3 +1,3 @@
-import { type RagDeleteWorkspaceParams } from "../../../../schemas/index";
+import { type RagDeleteWorkspaceParams } from '../../../../schemas/index';
 export declare function deleteWorkspace(params: RagDeleteWorkspaceParams): Promise<void>;
 //# sourceMappingURL=delete-workspace.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/delete-workspace.js

@@ -1,6 +1,6 @@
-import { isWorkspaceLoaded, deleteWorkspace as deleteWorkspaceFromManager, } from "../rag-workspace-manager.js";
-import { ragDeleteWorkspaceParamsSchema, } from "../../../../schemas/index.js";
-import { RAGWorkspaceNotFoundError, RAGWorkspaceInUseError, } from "../../../../utils/errors-server.js";
+import { isWorkspaceLoaded, deleteWorkspace as deleteWorkspaceFromManager } from '../rag-workspace-manager.js';
+import { ragDeleteWorkspaceParamsSchema } from '../../../../schemas/index.js';
+import { RAGWorkspaceNotFoundError, RAGWorkspaceInUseError } from '../../../../utils/errors-server.js';
 export async function deleteWorkspace(params) {
     const { workspace } = ragDeleteWorkspaceParamsSchema.parse(params);
     // Check if workspace is currently in use

package/dist/server/bare/rag-hyperdb/handlers/ingest.d.ts

@@ -1,5 +1,5 @@
-import { type RagIngestParams } from "../../../../schemas/index";
-import type { IngestStage } from "@qvac/rag";
+import { type RagIngestParams } from '../../../../schemas/index';
+import type { IngestStage } from '@qvac/rag';
 interface IngestHandlerOptions {
     onProgress?: (stage: IngestStage, current: number, total: number) => void;
     signal?: AbortSignal;

package/dist/server/bare/rag-hyperdb/handlers/ingest.js

@@ -1,6 +1,6 @@
-import { getRagInstance } from "../rag-workspace-manager.js";
-import { embed } from "../../ops/embed.js";
-import { ragIngestParamsSchema } from "../../../../schemas/index.js";
+import { getRagInstance } from '../rag-workspace-manager.js';
+import { embed } from '../../ops/embed.js';
+import { ragIngestParamsSchema } from '../../../../schemas/index.js';
 export async function ingest(params, options) {
     const { modelId, documents, chunk, chunkOpts, workspace, progressInterval } = ragIngestParamsSchema.parse(params);
     async function embeddingFunction(text) {
@@ -13,7 +13,7 @@ export async function ingest(params, options) {
         chunkOpts,
         progressInterval,
         onProgress: options?.onProgress,
-        signal: options?.signal,
+        signal: options?.signal
     };
     return await rag.ingest(documents, modelId, ingestOpts);
 }

package/dist/server/bare/rag-hyperdb/handlers/list-workspaces.d.ts

@@ -1,3 +1,3 @@
-import { type RagWorkspaceInfo } from "../rag-workspace-manager";
+import { type RagWorkspaceInfo } from '../rag-workspace-manager';
 export declare function listWorkspaces(): RagWorkspaceInfo[];
 //# sourceMappingURL=list-workspaces.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/list-workspaces.js

@@ -1,4 +1,4 @@
-import { listWorkspaces as listWorkspacesFromManager, } from "../rag-workspace-manager.js";
+import { listWorkspaces as listWorkspacesFromManager } from '../rag-workspace-manager.js';
 export function listWorkspaces() {
     return listWorkspacesFromManager();
 }