@qvac/sdk 0.10.2 → 0.12.0

package/dist/server/bare/plugins/{onnx-tts → tts-ggml}/ops/text-to-speech-stream.js

@@ -10,24 +10,14 @@ function hasRunStreaming(model) {
         "runStreaming" in model &&
         typeof model.runStreaming === "function");
 }
-// Callers (e.g. LLM token deltas) may write raw Buffer chunks whose
-// boundaries split a multi-byte UTF-8 codepoint. A naive `buf.toString("utf8")`
-// per chunk emits U+FFFD at every split point and silently corrupts CJK,
-// emoji, accented scripts, etc. before they reach the tokenizer. Keep a
-// tail-buffer of at most 3 bytes spanning an incomplete trailing codepoint
-// and decode only the complete-codepoint prefix of each combined chunk.
 function findLastCompleteUtf8End(buf) {
     const len = buf.length;
-    // A UTF-8 codepoint is at most 4 bytes, so a split can only dangle in
-    // the last 3 bytes. Scan backwards to find the most recent leading byte.
     for (let i = len - 1; i >= 0 && i >= len - 3; i--) {
         const b = buf[i];
         if ((b & 0x80) === 0) {
-            // ASCII byte: everything up to and including i is complete.
             return i + 1;
         }
         if ((b & 0xc0) === 0xc0) {
-            // Leading byte of a multi-byte sequence.
             let expected;
             if ((b & 0xe0) === 0xc0)
                 expected = 2;
@@ -36,7 +26,7 @@ function findLastCompleteUtf8End(buf) {
             else if ((b & 0xf8) === 0xf0)
                 expected = 4;
             else
-                return len; // Invalid leader; let toString emit U+FFFD.
+                return len;
             return i + expected <= len ? len : i;
         }
     }
@@ -59,9 +49,6 @@ async function* buffersToUtf8Fragments(inputStream) {
                 : Buffer.alloc(0);
     }
     if (pending.length > 0) {
-        // Stream ended with a dangling partial codepoint — flush as-is so the
-        // tokenizer sees the replacement character rather than silently dropping
-        // the final byte(s).
         const s = pending.toString("utf8");
         if (s.length > 0) {
             yield s;
@@ -89,7 +76,7 @@ export async function* textToSpeechStream(params, inputStream) {
     const model = getModel(request.modelId);
     const modelStart = nowMs();
     if (!hasRunStreaming(model)) {
-        throw new TextToSpeechStreamFailedError("textToSpeechStream requires an ONNX TTS model with runStreaming");
+        throw new TextToSpeechStreamFailedError("textToSpeechStream requires a TTS model with runStreaming");
     }
     const textSource = buffersToUtf8Fragments(inputStream);
     const streamOpts = buildRunStreamingOptions(request);

package/dist/server/bare/plugins/{onnx-tts → tts-ggml}/ops/text-to-speech.js

@@ -16,7 +16,7 @@ export async function* textToSpeech(params) {
     const modelStart = nowMs();
     if (sentenceStream) {
         if (!hasRunStream(model)) {
-            throw new TextToSpeechFailedError("sentenceStream requires an ONNX TTS model with runStream (Supertonic)");
+            throw new TextToSpeechFailedError("sentenceStream requires a TTS model with runStream");
         }
         const streamOpts = sentenceStreamLocale !== undefined || sentenceStreamMaxChunkScalars !== undefined
             ? {
@@ -62,6 +62,7 @@ export async function* textToSpeech(params) {
     const response = (await model.run({
         input: text,
         inputType,
+        ...(stream ? { streamOutput: true } : {}),
     }));
     if (!stream) {
         let completeBuffer = [];

package/dist/server/bare/plugins/tts-ggml/plugin.d.ts

@@ -0,0 +1,75 @@
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
+export declare const ttsPlugin: {
+    modelType: "tts-ggml";
+    displayName: string;
+    addonPackage: "@qvac/tts-ggml";
+    loadConfigSchema: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        [x: string]: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        [x: string]: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strict>]>;
+    resolveConfig(cfg: Record<string, unknown>, ctx: ResolveContext): Promise<ResolveResult<{
+        ttsEngine: "supertonic";
+        language: "en" | "de" | "es" | "it";
+        voice?: string | undefined;
+        ttsSpeed?: number | undefined;
+        ttsNumInferenceSteps?: number | undefined;
+        useGPU?: boolean | undefined;
+    } | {
+        ttsEngine: "chatterbox";
+        language: "en" | "de" | "es" | "it";
+        voice?: string | undefined;
+        useGPU?: boolean | undefined;
+    }, string>>;
+    createModel(params: CreateModelParams): PluginModelResult;
+    handlers: {
+        textToSpeech: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            inputType: import("zod").ZodDefault<import("zod").ZodString>;
+            text: import("zod").ZodString;
+            stream: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            sentenceStream: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            sentenceStreamLocale: import("zod").ZodOptional<import("zod").ZodString>;
+            sentenceStreamMaxChunkScalars: import("zod").ZodOptional<import("zod").ZodNumber>;
+            type: import("zod").ZodLiteral<"textToSpeech">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"textToSpeech">;
+            buffer: import("zod").ZodArray<import("zod").ZodNumber>;
+            done: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            stats: import("zod").ZodOptional<import("zod").ZodObject<{
+                audioDuration: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalSamples: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+            chunkIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
+            sentenceChunk: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        textToSpeechStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            inputType: import("zod").ZodDefault<import("zod").ZodString>;
+            accumulateSentences: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            sentenceDelimiterPreset: import("zod").ZodOptional<import("zod").ZodEnum<{
+                latin: "latin";
+                cjk: "cjk";
+                multilingual: "multilingual";
+            }>>;
+            maxBufferScalars: import("zod").ZodOptional<import("zod").ZodNumber>;
+            flushAfterMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+            type: import("zod").ZodLiteral<"textToSpeechStream">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"textToSpeechStream">;
+            buffer: import("zod").ZodArray<import("zod").ZodNumber>;
+            done: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            stats: import("zod").ZodOptional<import("zod").ZodObject<{
+                audioDuration: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalSamples: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+            chunkIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
+            sentenceChunk: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    };
+    logging: {
+        module: import("@qvac/tts-ggml/addonLogging").AddonLogging;
+        namespace: "tts-ggml";
+    };
+};
+//# sourceMappingURL=plugin.d.ts.map

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

@@ -0,0 +1,189 @@
+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);
+    if (legacyFields.length > 0) {
+        throw new LegacyTtsModelDeprecatedError(legacyFields);
+    }
+}
+async function resolveChatterboxConfig(config, ctx) {
+    rejectLegacyOnnxFields(config);
+    const { s3genModelSrc, referenceAudioSrc, ...runtime } = config;
+    if (!s3genModelSrc) {
+        throw new TtsArtifactsRequiredError();
+    }
+    const resolve = ctx.resolveModelPath;
+    const [s3genPath, referenceAudioPath] = await Promise.all([
+        resolve(s3genModelSrc),
+        referenceAudioSrc ? resolve(referenceAudioSrc) : Promise.resolve(undefined),
+    ]);
+    return {
+        config: runtime,
+        artifacts: {
+            s3genPath,
+            ...(referenceAudioPath ? { referenceAudioPath } : {}),
+        },
+    };
+}
+function resolveSupertonicConfig(config) {
+    rejectLegacyOnnxFields(config);
+    return Promise.resolve({ config });
+}
+function createChatterboxModel(modelId, config, params, artifacts) {
+    const t3Model = params.modelPath;
+    const s3genModel = artifacts["s3genPath"];
+    const referenceAudioPath = artifacts["referenceAudioPath"];
+    if (!t3Model || !s3genModel) {
+        throw new TtsArtifactsRequiredError();
+    }
+    const logger = createStreamLogger(modelId, ModelType.ttsGgml);
+    registerAddonLogger(modelId, ModelType.ttsGgml, logger);
+    const model = new TTSGgml({
+        engine: TTSGgml.ENGINE_CHATTERBOX,
+        files: { t3Model, s3genModel },
+        ...(referenceAudioPath ? { referenceAudio: referenceAudioPath } : {}),
+        config: {
+            language: config.language ?? "en",
+            ...(config.useGPU !== undefined ? { useGPU: config.useGPU } : {}),
+        },
+        logger,
+        opts: { stats: true },
+        exclusiveRun: true,
+    });
+    return { model };
+}
+function createSupertonicModel(modelId, config, params) {
+    const supertonicModel = params.modelPath;
+    if (!supertonicModel) {
+        throw new TtsArtifactsRequiredError();
+    }
+    const logger = createStreamLogger(modelId, ModelType.ttsGgml);
+    registerAddonLogger(modelId, ModelType.ttsGgml, logger);
+    const model = new TTSGgml({
+        engine: TTSGgml.ENGINE_SUPERTONIC,
+        files: { supertonicModel },
+        voice: config.voice ?? "F1",
+        ...(config.ttsSpeed !== undefined ? { speed: config.ttsSpeed } : {}),
+        ...(config.ttsNumInferenceSteps !== undefined
+            ? { numInferenceSteps: config.ttsNumInferenceSteps }
+            : {}),
+        config: {
+            language: config.language ?? "en",
+            useGPU: config.useGPU ?? false,
+        },
+        logger,
+        opts: { stats: true },
+        exclusiveRun: true,
+    });
+    return { model };
+}
+export const ttsPlugin = definePlugin({
+    modelType: ModelType.ttsGgml,
+    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);
+        }
+        return resolveChatterboxConfig(cfg, ctx);
+    },
+    createModel(params) {
+        const config = (params.modelConfig ?? {});
+        const artifacts = params.artifacts ?? {};
+        if (config.ttsEngine === "supertonic") {
+            return createSupertonicModel(params.modelId, config, params);
+        }
+        return createChatterboxModel(params.modelId, config, params, artifacts);
+    },
+    handlers: {
+        textToSpeech: defineHandler({
+            requestSchema: ttsRequestSchema,
+            responseSchema: ttsResponseSchema,
+            streaming: 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",
+                            buffer: result.value.buffer,
+                            done: false,
+                            ...(result.value.chunkIndex !== undefined
+                                ? { chunkIndex: result.value.chunkIndex }
+                                : {}),
+                            ...(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",
+                        buffer: [],
+                        done: true,
+                        ...(stats && { stats }),
+                    }, modelExecutionMs);
+                }
+                finally {
+                    await stream.return?.(undefined);
+                }
+            },
+        }),
+        textToSpeechStream: defineDuplexHandler({
+            requestSchema: textToSpeechStreamRequestSchema,
+            responseSchema: textToSpeechStreamResponseSchema,
+            streaming: true,
+            duplex: 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",
+                            buffer: result.value.buffer,
+                            done: false,
+                            ...(result.value.chunkIndex !== undefined
+                                ? { chunkIndex: result.value.chunkIndex }
+                                : {}),
+                            ...(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",
+                        buffer: [],
+                        done: true,
+                        ...(stats && { stats }),
+                    }, modelExecutionMs);
+                }
+                finally {
+                    await stream.return?.(undefined);
+                }
+            },
+        }),
+    },
+    logging: {
+        module: ttsAddonLogging,
+        namespace: ModelType.ttsGgml,
+    },
+});

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

@@ -76,21 +76,26 @@ export declare const whisperPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
+                vla: "vla";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
                 "nmtcpp-translation": "nmtcpp-translation";
                 "onnx-tts": "onnx-tts";
+                "tts-ggml": "tts-ggml";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
                 "sdcpp-generation": "sdcpp-generation";
+                "ggml-vla": "ggml-vla";
+                "ggml-classification": "ggml-classification";
                 llm: "llm";
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
+                classification: "classification";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
     }, import("zod/v4/core").$strip>;
@@ -225,6 +230,7 @@ export declare const whisperPlugin: {
                 value: import("zod").ZodString;
             }, import("zod/v4/core").$strip>], "type">;
             type: import("zod").ZodLiteral<"transcribe">;
+            requestId: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             text: import("zod").ZodOptional<import("zod").ZodString>;
             done: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -248,6 +254,16 @@ export declare const whisperPlugin: {
                 append: import("zod").ZodBoolean;
                 id: import("zod").ZodNumber;
             }, import("zod/v4/core").$strip>>;
+            vad: import("zod").ZodOptional<import("zod").ZodObject<{
+                speaking: import("zod").ZodBoolean;
+                probability: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            endOfTurn: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                source: import("zod").ZodLiteral<"whisper">;
+                silenceDurationMs: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                source: import("zod").ZodLiteral<"parakeet">;
+            }, import("zod/v4/core").$strip>], "source">>>;
             type: import("zod").ZodLiteral<"transcribe">;
         }, import("zod/v4/core").$strip>>;
         transcribeStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
@@ -255,6 +271,24 @@ export declare const whisperPlugin: {
             prompt: import("zod").ZodOptional<import("zod").ZodString>;
             metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
             type: import("zod").ZodLiteral<"transcribeStream">;
+            emitVadEvents: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            endOfTurnSilenceMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+            vadRunIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+            parakeetStreamingConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+                chunkMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                historyMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                leftContextMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                rightLookaheadMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                emitPartials: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                emitEnergyVad: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                spkCacheEnable: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                spkCacheLen: import("zod").ZodOptional<import("zod").ZodNumber>;
+                fifoLen: import("zod").ZodOptional<import("zod").ZodNumber>;
+                chunkLeftContextMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                chunkRightContextMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                spkCacheUpdatePeriod: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+            requestId: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             text: import("zod").ZodOptional<import("zod").ZodString>;
             done: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -278,6 +312,16 @@ export declare const whisperPlugin: {
                 append: import("zod").ZodBoolean;
                 id: import("zod").ZodNumber;
             }, import("zod/v4/core").$strip>>;
+            vad: import("zod").ZodOptional<import("zod").ZodObject<{
+                speaking: import("zod").ZodBoolean;
+                probability: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            endOfTurn: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                source: import("zod").ZodLiteral<"whisper">;
+                silenceDurationMs: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                source: import("zod").ZodLiteral<"parakeet">;
+            }, import("zod/v4/core").$strip>], "source">>>;
             type: import("zod").ZodLiteral<"transcribeStream">;
         }, import("zod/v4/core").$strip>>;
     };

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

@@ -52,6 +52,9 @@ export const whisperPlugin = definePlugin({
             requestSchema: transcribeRequestSchema,
             responseSchema: transcribeResponseSchema,
             streaming: true,
+            // whisper.cpp addon exposes a model-wide hard cancel — compute
+            // is interrupted on the currently-running transcription.
+            cancel: { scope: "model", hard: true },
             handler: async function* (request) {
                 const metadata = request.metadata === true;
                 const stream = metadata
@@ -60,12 +63,12 @@ export const whisperPlugin = definePlugin({
                         audioChunk: request.audioChunk,
                         prompt: request.prompt,
                         metadata: true,
-                    })
+                    }, request.requestId)
                     : transcribe({
                         modelId: request.modelId,
                         audioChunk: request.audioChunk,
                         prompt: request.prompt,
-                    });
+                    }, request.requestId);
                 try {
                     let result = await stream.next();
                     while (!result.done) {
@@ -98,22 +101,66 @@ export const whisperPlugin = definePlugin({
             responseSchema: transcribeStreamResponseSchema,
             streaming: true,
             duplex: true,
+            // Same model-wide hard cancel surface as `transcribe` — both
+            // route through the whisper.cpp addon.
+            cancel: { scope: "model", hard: true },
             handler: async function* (request, inputStream) {
-                if (request.metadata === true) {
-                    for await (const segment of transcribeStream(request.modelId, inputStream, request.prompt, true)) {
-                        yield {
-                            type: "transcribeStream",
-                            segment,
-                        };
+                const streamOpts = {
+                    ...(request.emitVadEvents !== undefined && {
+                        emitVadEvents: request.emitVadEvents,
+                    }),
+                    ...(request.endOfTurnSilenceMs !== undefined && {
+                        endOfTurnSilenceMs: request.endOfTurnSilenceMs,
+                    }),
+                    ...(request.vadRunIntervalMs !== undefined && {
+                        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") {
+                            yield {
+                                type: "transcribeStream",
+                                vad: {
+                                    speaking: value.speaking,
+                                    probability: value.probability,
+                                },
+                            };
+                            continue;
+                        }
+                        if (value.type === "endOfTurn") {
+                            // Whisper addon emits legacy `{ type, silenceDurationMs }` frames
+                            // without `source`. Parakeet must never surface here.
+                            if (value.source === "parakeet") {
+                                continue;
+                            }
+                            if (typeof value.silenceDurationMs !== "number") {
+                                continue;
+                            }
+                            yield {
+                                type: "transcribeStream",
+                                endOfTurn: {
+                                    source: "whisper",
+                                    silenceDurationMs: value.silenceDurationMs,
+                                },
+                            };
+                            continue;
+                        }
+                        continue;
                     }
-                }
-                else {
-                    for await (const text of transcribeStream(request.modelId, inputStream, request.prompt)) {
-                        yield {
+                    yield metadata
+                        ? {
                             type: "transcribeStream",
-                            text,
+                            segment: value,
+                        }
+                        : {
+                            type: "transcribeStream",
+                            text: value,
                         };
-                    }
                 }
                 yield {
                     type: "transcribeStream",

package/dist/server/bare/rag-hyperdb/index.d.ts

@@ -8,5 +8,5 @@ export { listWorkspaces } from "./handlers/list-workspaces";
 export { closeWorkspace } from "./handlers/close-workspace";
 export { deleteWorkspace } from "./handlers/delete-workspace";
 export { closeAllRagInstances, DEFAULT_WORKSPACE, type RagWorkspaceInfo, } from "./rag-workspace-manager";
-export { registerRagOperation, unregisterRagOperation, cancelRagOperation, } from "./rag-operation-manager";
+export { getActiveRagRequest, setActiveRagRequest, clearActiveRagRequest, getWorkspaceKey, } from "./rag-operation-manager";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/bare/rag-hyperdb/index.js

@@ -8,4 +8,4 @@ export { listWorkspaces } from "./handlers/list-workspaces.js";
 export { closeWorkspace } from "./handlers/close-workspace.js";
 export { deleteWorkspace } from "./handlers/delete-workspace.js";
 export { closeAllRagInstances, DEFAULT_WORKSPACE, } from "./rag-workspace-manager.js";
-export { registerRagOperation, unregisterRagOperation, cancelRagOperation, } from "./rag-operation-manager.js";
+export { getActiveRagRequest, setActiveRagRequest, clearActiveRagRequest, getWorkspaceKey, } from "./rag-operation-manager.js";

package/dist/server/bare/rag-hyperdb/rag-operation-manager.d.ts

@@ -1,7 +1,29 @@
-import { type AbortSignal } from "bare-abort-controller";
 export declare function getWorkspaceKey(workspace?: string): string;
-export declare function registerRagOperation(workspace: string | undefined, operation: string): AbortSignal;
-export declare function unregisterRagOperation(workspace?: string): void;
-export declare function cancelRagOperation(workspace?: string): boolean;
+/**
+ * Returns the `requestId` of any in-flight RAG operation on the workspace
+ * (or `undefined` if none). The dispatcher uses this to decide whether to
+ * pre-empt before calling `registry.begin(...)`.
+ */
+export declare function getActiveRagRequest(workspace?: string): string | undefined;
+/**
+ * Records the `requestId` of a freshly-begun RAG operation. Called by the
+ * dispatcher in `rag.ts` after `registry.begin(...)` succeeds; paired with
+ * `clearActiveRagRequest` via the request scope's deferred cleanup so the
+ * map never outlives the request.
+ */
+export declare function setActiveRagRequest(workspace: string | undefined, requestId: string): void;
+/**
+ * Clears the workspace's mapping iff it still belongs to `requestId`. The
+ * conditional guard handles the natural race between two ingest calls on
+ * the same workspace: the older context's scope unwind must not stomp the
+ * newer context's mapping installed by the pre-emption sequence.
+ */
+export declare function clearActiveRagRequest(workspace: string | undefined, requestId: string): void;
+/**
+ * Shutdown / workspace-close sweep. Cancels every tracked RAG request via
+ * the registry and clears the workspace map. Idempotent — callers that
+ * re-invoke during a teardown (workspace-close fired twice, shutdown
+ * racing with `close-all`) get a no-op on the second pass.
+ */
 export declare function cancelAllRagOperations(): void;
 //# sourceMappingURL=rag-operation-manager.d.ts.map