@qvac/sdk 0.14.1 → 0.15.0

package/dist/server/bare/plugins/tts-ggml/ops/text-to-speech.d.ts

@@ -1,5 +1,5 @@
-import { type TtsRequest, type TtsStats } from "../../../../../schemas/index";
-import { type TtsOpYield } from "../../../utils/tts-stats";
+import { type TtsRequest, type TtsStats } from '../../../../../schemas/index';
+import { type TtsOpYield } from '../../../utils/tts-stats';
 export declare function textToSpeech(params: TtsRequest): AsyncGenerator<TtsOpYield, {
     modelExecutionMs: number;
     stats?: TtsStats;

package/dist/server/bare/plugins/tts-ggml/ops/text-to-speech.js

@@ -1,31 +1,29 @@
-import { getModel } from "../../../registry/model-registry.js";
-import { ttsRequestSchema, } from "../../../../../schemas/index.js";
-import { nowMs } from "../../../../../profiling/index.js";
-import { buildStreamResult, hasDefinedValues } from "../../../../../profiling/model-execution.js";
-import { TextToSpeechFailedError } from "../../../../../utils/errors-server.js";
-import { collectTtsStats, } from "../../../utils/tts-stats.js";
+import { getModel } from '../../../registry/model-registry.js';
+import { ttsRequestSchema } from '../../../../../schemas/index.js';
+import { nowMs } from '../../../../../profiling/index.js';
+import { buildStreamResult, hasDefinedValues } from '../../../../../profiling/model-execution.js';
+import { TextToSpeechFailedError } from '../../../../../utils/errors-server.js';
+import { collectTtsStats } from '../../../utils/tts-stats.js';
 function hasRunStream(model) {
-    return (typeof model === "object" &&
+    return (typeof model === 'object' &&
         model !== null &&
-        "runStream" in model &&
-        typeof model.runStream === "function");
+        'runStream' in model &&
+        typeof model.runStream === 'function');
 }
 export async function* textToSpeech(params) {
-    const { modelId, inputType, text, stream, sentenceStream, sentenceStreamLocale, sentenceStreamMaxChunkScalars, } = ttsRequestSchema.parse(params);
+    const { modelId, inputType, text, stream, sentenceStream, sentenceStreamLocale, sentenceStreamMaxChunkScalars } = ttsRequestSchema.parse(params);
     const model = getModel(modelId);
     const modelStart = nowMs();
     if (sentenceStream) {
         if (!hasRunStream(model)) {
-            throw new TextToSpeechFailedError("sentenceStream requires a TTS model with runStream");
+            throw new TextToSpeechFailedError('sentenceStream requires a TTS model with runStream');
         }
         const streamOpts = sentenceStreamLocale !== undefined || sentenceStreamMaxChunkScalars !== undefined
             ? {
-                ...(sentenceStreamLocale !== undefined
-                    ? { locale: sentenceStreamLocale }
-                    : {}),
+                ...(sentenceStreamLocale !== undefined ? { locale: sentenceStreamLocale } : {}),
                 ...(sentenceStreamMaxChunkScalars !== undefined
                     ? { maxChunkScalars: sentenceStreamMaxChunkScalars }
-                    : {}),
+                    : {})
             }
             : undefined;
         const response = await model.runStream(text, streamOpts);
@@ -50,9 +48,9 @@ export async function* textToSpeech(params) {
             yield {
                 buffer: buf,
                 ...(data.chunkIndex !== undefined ? { chunkIndex: data.chunkIndex } : {}),
-                ...(typeof data.sentenceChunk === "string" && data.sentenceChunk.length > 0
+                ...(typeof data.sentenceChunk === 'string' && data.sentenceChunk.length > 0
                     ? { sentenceChunk: data.sentenceChunk }
-                    : {}),
+                    : {})
             };
         }
         const modelExecutionMs = nowMs() - modelStart;
@@ -62,7 +60,7 @@ export async function* textToSpeech(params) {
     const response = (await model.run({
         input: text,
         inputType,
-        ...(stream ? { streamOutput: true } : {}),
+        ...(stream ? { streamOutput: true } : {})
     }));
     if (!stream) {
         let completeBuffer = [];
@@ -72,11 +70,11 @@ export async function* textToSpeech(params) {
         const modelExecutionMs = nowMs() - modelStart;
         const stats = {
             ...(response.stats?.audioDurationMs !== undefined && {
-                audioDuration: response.stats.audioDurationMs,
+                audioDuration: response.stats.audioDurationMs
             }),
             ...(response.stats?.totalSamples !== undefined && {
-                totalSamples: response.stats.totalSamples,
-            }),
+                totalSamples: response.stats.totalSamples
+            })
         };
         yield { buffer: completeBuffer };
         return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
@@ -87,11 +85,11 @@ export async function* textToSpeech(params) {
     const modelExecutionMs = nowMs() - modelStart;
     const stats = {
         ...(response.stats?.audioDurationMs !== undefined && {
-            audioDuration: response.stats.audioDurationMs,
+            audioDuration: response.stats.audioDurationMs
         }),
         ...(response.stats?.totalSamples !== undefined && {
-            totalSamples: response.stats.totalSamples,
-        }),
+            totalSamples: response.stats.totalSamples
+        })
     };
     return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
 }

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

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult } from '../../../../schemas/index';
 export declare const ttsPlugin: {
     modelType: "tts-ggml";
     displayName: string;
@@ -10,7 +10,7 @@ export declare const ttsPlugin: {
     }, import("zod/v4/core").$strict>], "ttsEngine">;
     resolveConfig(cfg: Record<string, unknown>, ctx: ResolveContext): Promise<ResolveResult<{
         ttsEngine: "chatterbox";
-        language: "en" | "ar" | "de" | "es" | "fi" | "fr" | "it" | "ko" | "nl" | "pl" | "pt" | "ru" | "zh" | "da" | "el" | "he" | "hi" | "ms" | "no" | "sv" | "tr" | "sw";
+        language: "en" | "ar" | "de" | "es" | "fi" | "fr" | "it" | "ja" | "ko" | "nl" | "pl" | "pt" | "ru" | "zh" | "da" | "el" | "he" | "hi" | "ms" | "no" | "sv" | "tr" | "sw";
         voice?: string | undefined;
         useGPU?: boolean | undefined;
         streamChunkTokens?: number | undefined;
@@ -26,6 +26,7 @@ export declare const ttsPlugin: {
         ttsSpeed?: number | undefined;
         ttsNumInferenceSteps?: number | undefined;
         useGPU?: boolean | undefined;
+        outputSampleRate?: number | undefined;
     }, string>>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {

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 }
@@ -57,21 +102,19 @@ function createChatterboxModel(modelId, config, params, artifacts) {
             : {}),
         ...(config.cfmSteps !== undefined ? { cfmSteps: config.cfmSteps } : {}),
         ...(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 +123,43 @@ 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 }
+                : {})
         },
         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 +168,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
+    }
 });