@getpaseo/server 0.1.83 → 0.1.85

package/dist/server/server/speech/providers/local/runtime.js

@@ -1,11 +1,7 @@
-import { PocketTtsOnnxTTS } from "./pocket/pocket-tts-onnx.js";
 import { getLocalSpeechModelDir, DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, } from "./models.js";
 import { SherpaOfflineRecognizerEngine } from "./sherpa/sherpa-offline-recognizer.js";
-import { SherpaOnlineRecognizerEngine } from "./sherpa/sherpa-online-recognizer.js";
 import { SherpaOnnxParakeetSTT } from "./sherpa/sherpa-parakeet-stt.js";
 import { SherpaParakeetRealtimeTranscriptionSession } from "./sherpa/sherpa-parakeet-realtime-session.js";
-import { SherpaRealtimeTranscriptionSession } from "./sherpa/sherpa-realtime-session.js";
-import { SherpaOnnxSTT } from "./sherpa/sherpa-stt.js";
 import { SherpaOnnxTTS } from "./sherpa/sherpa-tts.js";
 import { ensureSileroVadModel, SherpaSileroTurnDetectionProvider, } from "./sherpa/silero-vad-provider.js";
 function buildModelDownloadHint(modelId) {
@@ -43,58 +39,18 @@ function computeRequiredLocalModelIds(params) {
 }
 async function createLocalSttEngine(params) {
     const { modelId, modelsDir, logger } = params;
-    if (modelId === "parakeet-tdt-0.6b-v3-int8" || modelId === "parakeet-tdt-0.6b-v2-int8") {
-        const modelDir = getLocalSpeechModelDir(modelsDir, modelId);
-        return {
-            kind: "offline",
-            engine: new SherpaOfflineRecognizerEngine({
-                model: {
-                    kind: "nemo_transducer",
-                    encoder: `${modelDir}/encoder.int8.onnx`,
-                    decoder: `${modelDir}/decoder.int8.onnx`,
-                    joiner: `${modelDir}/joiner.int8.onnx`,
-                    tokens: `${modelDir}/tokens.txt`,
-                },
-                numThreads: 2,
-                debug: 0,
-            }, logger),
-        };
-    }
-    if (modelId === "paraformer-bilingual-zh-en") {
-        const modelDir = getLocalSpeechModelDir(modelsDir, modelId);
-        return {
-            kind: "online",
-            engine: new SherpaOnlineRecognizerEngine({
-                model: {
-                    kind: "paraformer",
-                    encoder: `${modelDir}/encoder.int8.onnx`,
-                    decoder: `${modelDir}/decoder.int8.onnx`,
-                    tokens: `${modelDir}/tokens.txt`,
-                },
-                numThreads: 1,
-                debug: 0,
-            }, logger),
-        };
-    }
-    if (modelId === "zipformer-bilingual-zh-en-2023-02-20") {
-        const modelDir = getLocalSpeechModelDir(modelsDir, modelId);
-        return {
-            kind: "online",
-            engine: new SherpaOnlineRecognizerEngine({
-                model: {
-                    kind: "transducer",
-                    encoder: `${modelDir}/encoder-epoch-99-avg-1.onnx`,
-                    decoder: `${modelDir}/decoder-epoch-99-avg-1.onnx`,
-                    joiner: `${modelDir}/joiner-epoch-99-avg-1.onnx`,
-                    tokens: `${modelDir}/tokens.txt`,
-                    modelType: "zipformer",
-                },
-                numThreads: 1,
-                debug: 0,
-            }, logger),
-        };
-    }
-    throw new Error(`Unsupported local STT model '${modelId}'`);
+    const modelDir = getLocalSpeechModelDir(modelsDir, modelId);
+    return new SherpaOfflineRecognizerEngine({
+        model: {
+            kind: "nemo_transducer",
+            encoder: `${modelDir}/encoder.int8.onnx`,
+            decoder: `${modelDir}/decoder.int8.onnx`,
+            joiner: `${modelDir}/joiner.int8.onnx`,
+            tokens: `${modelDir}/tokens.txt`,
+        },
+        numThreads: 2,
+        debug: 0,
+    }, logger);
 }
 function isLocalProviderEnabled(provider) {
     return provider.enabled !== false && provider.provider === "local";
@@ -118,13 +74,7 @@ async function initializeLocalVoiceStt(params) {
         return null;
     }
     const voiceEngine = await getLocalSttEngine(modelId);
-    if (voiceEngine?.kind === "offline") {
-        return new SherpaOnnxParakeetSTT({ engine: voiceEngine.engine }, logger);
-    }
-    if (voiceEngine?.kind === "online") {
-        return new SherpaOnnxSTT({ engine: voiceEngine.engine }, logger);
-    }
-    return null;
+    return voiceEngine ? new SherpaOnnxParakeetSTT({ engine: voiceEngine }, logger) : null;
 }
 async function initializeLocalDictationStt(params) {
     const { localConfig, modelId, logger, getLocalSttEngine } = params;
@@ -133,16 +83,10 @@ async function initializeLocalDictationStt(params) {
         return null;
     }
     const dictationEngine = await getLocalSttEngine(modelId);
-    if (dictationEngine?.kind === "offline") {
-        return {
-            id: "local",
-            createSession: () => new SherpaParakeetRealtimeTranscriptionSession({ engine: dictationEngine.engine }),
-        };
-    }
-    if (dictationEngine?.kind === "online") {
+    if (dictationEngine) {
         return {
             id: "local",
-            createSession: () => new SherpaRealtimeTranscriptionSession({ engine: dictationEngine.engine }),
+            createSession: () => new SherpaParakeetRealtimeTranscriptionSession({ engine: dictationEngine }),
         };
     }
     return null;
@@ -155,13 +99,6 @@ async function initializeLocalVoiceTts(params) {
     }
     try {
         const modelDir = getLocalSpeechModelDir(localConfig.modelsDir, localModels.voiceLocalTtsModel);
-        if (localModels.voiceLocalTtsModel === "pocket-tts-onnx-int8") {
-            return await PocketTtsOnnxTTS.create({
-                modelDir,
-                precision: "int8",
-                targetChunkMs: 50,
-            }, logger);
-        }
         return new SherpaOnnxTTS({
             preset: localModels.voiceLocalTtsModel,
             modelDir,
@@ -256,7 +193,7 @@ export async function initializeLocalSpeechServices(params) {
             maybeFreeable.free();
         }
         for (const engine of localSttEngines.values()) {
-            engine.engine.free();
+            engine.free();
         }
     };
     return {

package/dist/server/server/speech/providers/local/sherpa/model-catalog.d.ts

@@ -1,113 +1,45 @@
 import { z } from "zod";
-export type SherpaOnnxModelKind = "stt-online" | "stt-offline" | "tts";
+export type SherpaOnnxModelKind = "stt-offline" | "tts";
 type DefaultModelRole = "stt" | "tts";
 interface SherpaOnnxCatalogEntry {
     kind: SherpaOnnxModelKind;
-    archiveUrl?: string;
-    downloadFiles?: Array<{
-        url: string;
-        relPath: string;
-    }>;
+    archiveUrl: string;
     extractedDir: string;
     requiredFiles: string[];
     description: string;
-    aliases?: readonly string[];
     defaultFor?: DefaultModelRole;
 }
 export declare const SHERPA_ONNX_MODEL_CATALOG: {
-    readonly "zipformer-bilingual-zh-en-2023-02-20": {
-        readonly kind: "stt-online";
-        readonly archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-streaming-zipformer-bilingual-zh-en-2023-02-20.tar.bz2";
-        readonly extractedDir: "sherpa-onnx-streaming-zipformer-bilingual-zh-en-2023-02-20";
-        readonly requiredFiles: ["encoder-epoch-99-avg-1.onnx", "decoder-epoch-99-avg-1.onnx", "joiner-epoch-99-avg-1.onnx", "tokens.txt"];
-        readonly description: "Streaming Zipformer transducer (fast, good accuracy).";
-        readonly aliases: readonly ["zipformer", "zipformer-bilingual"];
-    };
-    readonly "paraformer-bilingual-zh-en": {
-        readonly kind: "stt-online";
-        readonly archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-streaming-paraformer-bilingual-zh-en.tar.bz2";
-        readonly extractedDir: "sherpa-onnx-streaming-paraformer-bilingual-zh-en";
-        readonly requiredFiles: ["encoder.int8.onnx", "decoder.int8.onnx", "tokens.txt"];
-        readonly description: "Streaming Paraformer (often strong accuracy; heavier).";
-        readonly aliases: readonly ["paraformer"];
-    };
     readonly "parakeet-tdt-0.6b-v2-int8": {
         readonly kind: "stt-offline";
         readonly archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-parakeet-tdt-0.6b-v2-int8.tar.bz2";
         readonly extractedDir: "sherpa-onnx-nemo-parakeet-tdt-0.6b-v2-int8";
         readonly requiredFiles: ["encoder.int8.onnx", "decoder.int8.onnx", "joiner.int8.onnx", "tokens.txt"];
         readonly description: "NVIDIA Parakeet TDT v2 (offline NeMo transducer, English).";
-        readonly aliases: readonly ["parakeet-v2", "parakeet-tdt-v2"];
         readonly defaultFor: "stt";
     };
-    readonly "parakeet-tdt-0.6b-v3-int8": {
-        readonly kind: "stt-offline";
-        readonly archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8.tar.bz2";
-        readonly extractedDir: "sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8";
-        readonly requiredFiles: ["encoder.int8.onnx", "decoder.int8.onnx", "joiner.int8.onnx", "tokens.txt"];
-        readonly description: "NVIDIA Parakeet TDT v3 (offline NeMo transducer, multilingual).";
-        readonly aliases: readonly ["parakeet", "parakeet-v3", "parakeet-tdt"];
-    };
-    readonly "kitten-nano-en-v0_1-fp16": {
-        readonly kind: "tts";
-        readonly archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/kitten-nano-en-v0_1-fp16.tar.bz2";
-        readonly extractedDir: "kitten-nano-en-v0_1-fp16";
-        readonly requiredFiles: ["model.fp16.onnx", "voices.bin", "tokens.txt", "espeak-ng-data"];
-        readonly description: "KittenTTS (small, fast English TTS).";
-        readonly aliases: readonly ["kitten"];
-    };
     readonly "kokoro-en-v0_19": {
         readonly kind: "tts";
         readonly archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/kokoro-en-v0_19.tar.bz2";
         readonly extractedDir: "kokoro-en-v0_19";
         readonly requiredFiles: ["model.onnx", "voices.bin", "tokens.txt", "espeak-ng-data"];
         readonly description: "Kokoro TTS (higher quality; larger).";
-        readonly aliases: readonly ["kokoro"];
         readonly defaultFor: "tts";
     };
-    readonly "pocket-tts-onnx-int8": {
-        readonly kind: "tts";
-        readonly extractedDir: "pocket-tts-onnx-int8";
-        readonly downloadFiles: [{
-            readonly url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/mimi_encoder.onnx";
-            readonly relPath: "onnx/mimi_encoder.onnx";
-        }, {
-            readonly url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/text_conditioner.onnx";
-            readonly relPath: "onnx/text_conditioner.onnx";
-        }, {
-            readonly url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/flow_lm_main_int8.onnx";
-            readonly relPath: "onnx/flow_lm_main_int8.onnx";
-        }, {
-            readonly url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/flow_lm_flow_int8.onnx";
-            readonly relPath: "onnx/flow_lm_flow_int8.onnx";
-        }, {
-            readonly url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/mimi_decoder_int8.onnx";
-            readonly relPath: "onnx/mimi_decoder_int8.onnx";
-        }, {
-            readonly url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/tokenizer.model";
-            readonly relPath: "tokenizer.model";
-        }, {
-            readonly url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/reference_sample.wav";
-            readonly relPath: "reference_sample.wav";
-        }];
-        readonly requiredFiles: ["onnx/mimi_encoder.onnx", "onnx/text_conditioner.onnx", "onnx/flow_lm_main_int8.onnx", "onnx/flow_lm_flow_int8.onnx", "onnx/mimi_decoder_int8.onnx", "tokenizer.model", "reference_sample.wav"];
-        readonly description: "Pocket TTS ONNX (INT8) with streaming decode support (via onnxruntime).";
-        readonly aliases: readonly ["pocket", "pocket-tts"];
-    };
 };
 export type SherpaOnnxModelId = keyof typeof SHERPA_ONNX_MODEL_CATALOG;
 export type LocalSpeechModelId = SherpaOnnxModelId;
 type ModelIdByKind<K extends SherpaOnnxModelKind> = {
     [Id in SherpaOnnxModelId]: (typeof SHERPA_ONNX_MODEL_CATALOG)[Id]["kind"] extends K ? Id : never;
 }[SherpaOnnxModelId];
-export type LocalSttModelId = ModelIdByKind<"stt-online"> | ModelIdByKind<"stt-offline">;
+export type LocalSttModelId = ModelIdByKind<"stt-offline">;
 export type LocalTtsModelId = ModelIdByKind<"tts">;
 export declare const LOCAL_STT_MODEL_IDS: LocalSttModelId[];
 export declare const LOCAL_TTS_MODEL_IDS: LocalTtsModelId[];
-export declare const DEFAULT_LOCAL_STT_MODEL: LocalSttModelId;
-export declare const DEFAULT_LOCAL_TTS_MODEL: LocalTtsModelId;
-export declare const LocalSttModelIdSchema: z.ZodType<LocalSttModelId, z.ZodTypeDef, string>;
-export declare const LocalTtsModelIdSchema: z.ZodType<LocalTtsModelId, z.ZodTypeDef, string>;
+export declare const DEFAULT_LOCAL_STT_MODEL: "parakeet-tdt-0.6b-v2-int8";
+export declare const DEFAULT_LOCAL_TTS_MODEL: "kokoro-en-v0_19";
+export declare const LocalSttModelIdSchema: z.ZodType<"parakeet-tdt-0.6b-v2-int8", z.ZodTypeDef, string>;
+export declare const LocalTtsModelIdSchema: z.ZodType<"kokoro-en-v0_19", z.ZodTypeDef, string>;
 export type SherpaOnnxModelSpec = SherpaOnnxCatalogEntry & {
     id: SherpaOnnxModelId;
 };

package/dist/server/server/speech/providers/local/sherpa/model-catalog.js

@@ -1,105 +1,21 @@
 import { z } from "zod";
 export const SHERPA_ONNX_MODEL_CATALOG = {
-    "zipformer-bilingual-zh-en-2023-02-20": {
-        kind: "stt-online",
-        archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-streaming-zipformer-bilingual-zh-en-2023-02-20.tar.bz2",
-        extractedDir: "sherpa-onnx-streaming-zipformer-bilingual-zh-en-2023-02-20",
-        requiredFiles: [
-            "encoder-epoch-99-avg-1.onnx",
-            "decoder-epoch-99-avg-1.onnx",
-            "joiner-epoch-99-avg-1.onnx",
-            "tokens.txt",
-        ],
-        description: "Streaming Zipformer transducer (fast, good accuracy).",
-        aliases: ["zipformer", "zipformer-bilingual"],
-    },
-    "paraformer-bilingual-zh-en": {
-        kind: "stt-online",
-        archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-streaming-paraformer-bilingual-zh-en.tar.bz2",
-        extractedDir: "sherpa-onnx-streaming-paraformer-bilingual-zh-en",
-        requiredFiles: ["encoder.int8.onnx", "decoder.int8.onnx", "tokens.txt"],
-        description: "Streaming Paraformer (often strong accuracy; heavier).",
-        aliases: ["paraformer"],
-    },
     "parakeet-tdt-0.6b-v2-int8": {
         kind: "stt-offline",
         archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-parakeet-tdt-0.6b-v2-int8.tar.bz2",
         extractedDir: "sherpa-onnx-nemo-parakeet-tdt-0.6b-v2-int8",
         requiredFiles: ["encoder.int8.onnx", "decoder.int8.onnx", "joiner.int8.onnx", "tokens.txt"],
         description: "NVIDIA Parakeet TDT v2 (offline NeMo transducer, English).",
-        aliases: ["parakeet-v2", "parakeet-tdt-v2"],
         defaultFor: "stt",
     },
-    "parakeet-tdt-0.6b-v3-int8": {
-        kind: "stt-offline",
-        archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8.tar.bz2",
-        extractedDir: "sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8",
-        requiredFiles: ["encoder.int8.onnx", "decoder.int8.onnx", "joiner.int8.onnx", "tokens.txt"],
-        description: "NVIDIA Parakeet TDT v3 (offline NeMo transducer, multilingual).",
-        aliases: ["parakeet", "parakeet-v3", "parakeet-tdt"],
-    },
-    "kitten-nano-en-v0_1-fp16": {
-        kind: "tts",
-        archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/kitten-nano-en-v0_1-fp16.tar.bz2",
-        extractedDir: "kitten-nano-en-v0_1-fp16",
-        requiredFiles: ["model.fp16.onnx", "voices.bin", "tokens.txt", "espeak-ng-data"],
-        description: "KittenTTS (small, fast English TTS).",
-        aliases: ["kitten"],
-    },
     "kokoro-en-v0_19": {
         kind: "tts",
         archiveUrl: "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/kokoro-en-v0_19.tar.bz2",
         extractedDir: "kokoro-en-v0_19",
         requiredFiles: ["model.onnx", "voices.bin", "tokens.txt", "espeak-ng-data"],
         description: "Kokoro TTS (higher quality; larger).",
-        aliases: ["kokoro"],
         defaultFor: "tts",
     },
-    "pocket-tts-onnx-int8": {
-        kind: "tts",
-        extractedDir: "pocket-tts-onnx-int8",
-        downloadFiles: [
-            {
-                url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/mimi_encoder.onnx",
-                relPath: "onnx/mimi_encoder.onnx",
-            },
-            {
-                url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/text_conditioner.onnx",
-                relPath: "onnx/text_conditioner.onnx",
-            },
-            {
-                url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/flow_lm_main_int8.onnx",
-                relPath: "onnx/flow_lm_main_int8.onnx",
-            },
-            {
-                url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/flow_lm_flow_int8.onnx",
-                relPath: "onnx/flow_lm_flow_int8.onnx",
-            },
-            {
-                url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/mimi_decoder_int8.onnx",
-                relPath: "onnx/mimi_decoder_int8.onnx",
-            },
-            {
-                url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/tokenizer.model",
-                relPath: "tokenizer.model",
-            },
-            {
-                url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/reference_sample.wav",
-                relPath: "reference_sample.wav",
-            },
-        ],
-        requiredFiles: [
-            "onnx/mimi_encoder.onnx",
-            "onnx/text_conditioner.onnx",
-            "onnx/flow_lm_main_int8.onnx",
-            "onnx/flow_lm_flow_int8.onnx",
-            "onnx/mimi_decoder_int8.onnx",
-            "tokenizer.model",
-            "reference_sample.wav",
-        ],
-        description: "Pocket TTS ONNX (INT8) with streaming decode support (via onnxruntime).",
-        aliases: ["pocket", "pocket-tts"],
-    },
 };
 const ALL_MODEL_IDS = Object.keys(SHERPA_ONNX_MODEL_CATALOG).filter((k) => k in SHERPA_ONNX_MODEL_CATALOG);
 function isLocalSttModelId(id) {
@@ -122,37 +38,19 @@ function resolveDefaultModelId(role) {
 }
 export const DEFAULT_LOCAL_STT_MODEL = resolveDefaultModelId("stt");
 export const DEFAULT_LOCAL_TTS_MODEL = resolveDefaultModelId("tts");
-function buildAliasMap(modelIds) {
-    const aliasMap = {};
-    for (const modelId of modelIds) {
-        const aliases = SHERPA_ONNX_MODEL_CATALOG[modelId].aliases ?? [];
-        for (const alias of aliases) {
-            aliasMap[alias.trim().toLowerCase()] = modelId;
-        }
-    }
-    return aliasMap;
-}
-function createAliasedModelIdSchema(params) {
-    const validIds = new Set(params.modelIds);
+function createModelIdSchema(modelIds) {
+    const validIds = new Set(modelIds);
     return z
         .string()
         .trim()
         .toLowerCase()
-        .refine((value) => validIds.has(value) || Object.prototype.hasOwnProperty.call(params.aliases, value), {
+        .refine((value) => validIds.has(value), {
         message: "Invalid model id",
     })
-        .transform((value) => params.aliases[value] ?? value);
+        .transform((value) => value);
 }
-const STT_MODEL_ALIASES = buildAliasMap(LOCAL_STT_MODEL_IDS);
-const TTS_MODEL_ALIASES = buildAliasMap(LOCAL_TTS_MODEL_IDS);
-export const LocalSttModelIdSchema = createAliasedModelIdSchema({
-    modelIds: LOCAL_STT_MODEL_IDS,
-    aliases: STT_MODEL_ALIASES,
-});
-export const LocalTtsModelIdSchema = createAliasedModelIdSchema({
-    modelIds: LOCAL_TTS_MODEL_IDS,
-    aliases: TTS_MODEL_ALIASES,
-});
+export const LocalSttModelIdSchema = createModelIdSchema(LOCAL_STT_MODEL_IDS);
+export const LocalTtsModelIdSchema = createModelIdSchema(LOCAL_TTS_MODEL_IDS);
 export function listSherpaOnnxModels() {
     return ALL_MODEL_IDS.map((id) => Object.assign({ id }, SHERPA_ONNX_MODEL_CATALOG[id]));
 }

package/dist/server/server/speech/providers/local/sherpa/model-downloader.js

@@ -86,65 +86,40 @@ export async function ensureSherpaOnnxModel(options) {
     }
     logger.info({ modelsDir: options.modelsDir }, "Starting model download");
     try {
-        if (spec.archiveUrl) {
-            const downloadsDir = path.join(options.modelsDir, ".downloads");
-            const archiveFilename = path.basename(new URL(spec.archiveUrl).pathname);
-            const archivePath = path.join(downloadsDir, archiveFilename);
-            if (!(await isNonEmptyFile(archivePath))) {
-                await downloadToFile({
-                    url: spec.archiveUrl,
-                    outputPath: archivePath,
-                });
-            }
-            logger.info({
-                modelId: options.modelId,
-                archivePath,
-                modelDir,
-            }, "Extracting model archive");
-            await extractTarArchive(archivePath, options.modelsDir);
-            logger.info({
-                modelId: options.modelId,
-                modelDir,
-            }, "Verifying downloaded model files");
-            if (!(await hasRequiredFiles(modelDir, spec.requiredFiles))) {
-                throw new Error(`Downloaded and extracted ${archiveFilename}, but required files are still missing in ${modelDir}.`);
-            }
-            logger.info({
-                modelId: options.modelId,
-                archivePath,
-            }, "Finalizing model artifacts");
-            try {
-                await rm(archivePath, { force: true });
-            }
-            catch {
-                // ignore
-            }
-            logger.info({ modelDir }, "Model download completed");
-            return modelDir;
+        const downloadsDir = path.join(options.modelsDir, ".downloads");
+        const archiveFilename = path.basename(new URL(spec.archiveUrl).pathname);
+        const archivePath = path.join(downloadsDir, archiveFilename);
+        if (!(await isNonEmptyFile(archivePath))) {
+            await downloadToFile({
+                url: spec.archiveUrl,
+                outputPath: archivePath,
+            });
         }
-        if (spec.downloadFiles && spec.downloadFiles.length > 0) {
-            await mkdir(modelDir, { recursive: true });
-            await Promise.all(spec.downloadFiles.map(async (file) => {
-                const dst = path.join(modelDir, file.relPath);
-                if (await isNonEmptyFile(dst)) {
-                    return;
-                }
-                await downloadToFile({
-                    url: file.url,
-                    outputPath: dst,
-                });
-            }));
-            logger.info({
-                modelId: options.modelId,
-                modelDir,
-            }, "Verifying downloaded model files");
-            if (!(await hasRequiredFiles(modelDir, spec.requiredFiles))) {
-                throw new Error(`Downloaded files for ${options.modelId}, but required files are still missing in ${modelDir}.`);
-            }
-            logger.info({ modelDir }, "Model download completed");
-            return modelDir;
+        logger.info({
+            modelId: options.modelId,
+            archivePath,
+            modelDir,
+        }, "Extracting model archive");
+        await extractTarArchive(archivePath, options.modelsDir);
+        logger.info({
+            modelId: options.modelId,
+            modelDir,
+        }, "Verifying downloaded model files");
+        if (!(await hasRequiredFiles(modelDir, spec.requiredFiles))) {
+            throw new Error(`Downloaded and extracted ${archiveFilename}, but required files are still missing in ${modelDir}.`);
         }
-        throw new Error(`Model spec for ${options.modelId} has no archiveUrl or downloadFiles`);
+        logger.info({
+            modelId: options.modelId,
+            archivePath,
+        }, "Finalizing model artifacts");
+        try {
+            await rm(archivePath, { force: true });
+        }
+        catch {
+            // ignore
+        }
+        logger.info({ modelDir }, "Model download completed");
+        return modelDir;
     }
     catch (error) {
         logger.error({ err: error }, "Model download failed");

package/dist/server/server/speech/providers/local/sherpa/sherpa-tts.d.ts

@@ -1,6 +1,6 @@
 import type pino from "pino";
 import type { SpeechStreamResult, TextToSpeechProvider } from "../../../speech-provider.js";
-export type SherpaTtsPreset = "kokoro-en-v0_19" | "kitten-nano-en-v0_1-fp16";
+export type SherpaTtsPreset = "kokoro-en-v0_19";
 export interface SherpaTtsConfig {
     preset: SherpaTtsPreset;
     modelDir: string;

package/dist/server/server/speech/providers/local/sherpa/sherpa-tts.js

@@ -9,9 +9,6 @@ function assertFileExists(filePath, label) {
 }
 export class SherpaOnnxTTS {
     constructor(config, logger) {
-        if (config.preset !== "kokoro-en-v0_19" && config.preset !== "kitten-nano-en-v0_1-fp16") {
-            throw new Error(`Unsupported Sherpa TTS preset: ${config.preset}`);
-        }
         this.logger = logger.child({ module: "speech", provider: "local", component: "tts" });
         this.speakerId = config.speakerId ?? 0;
         this.speed = config.speed ?? 1.0;
@@ -19,8 +16,7 @@ export class SherpaOnnxTTS {
         if (typeof sherpa.OfflineTts !== "function") {
             throw new Error("sherpa-onnx-node OfflineTts is unavailable");
         }
-        const modelFile = config.preset === "kokoro-en-v0_19" ? "model.onnx" : "model.fp16.onnx";
-        const modelPath = `${config.modelDir}/${modelFile}`;
+        const modelPath = `${config.modelDir}/model.onnx`;
         const voicesPath = `${config.modelDir}/voices.bin`;
         const tokensPath = `${config.modelDir}/tokens.txt`;
         const dataDir = `${config.modelDir}/espeak-ng-data`;
@@ -28,25 +24,15 @@ export class SherpaOnnxTTS {
         assertFileExists(voicesPath, "TTS voices");
         assertFileExists(tokensPath, "TTS tokens");
         assertFileExists(dataDir, "TTS espeak-ng dataDir");
-        const modelConfig = config.preset === "kokoro-en-v0_19"
-            ? {
-                kokoro: {
-                    model: modelPath,
-                    voices: voicesPath,
-                    tokens: tokensPath,
-                    dataDir,
-                    lengthScale: config.lengthScale ?? 1.0,
-                },
-            }
-            : {
-                kitten: {
-                    model: modelPath,
-                    voices: voicesPath,
-                    tokens: tokensPath,
-                    dataDir,
-                    lengthScale: config.lengthScale ?? 1.0,
-                },
-            };
+        const modelConfig = {
+            kokoro: {
+                model: modelPath,
+                voices: voicesPath,
+                tokens: tokensPath,
+                dataDir,
+                lengthScale: config.lengthScale ?? 1.0,
+            },
+        };
         const offlineTtsConfig = {
             model: modelConfig,
             numThreads: config.numThreads ?? 2,

package/dist/server/server/voice-permission-policy.js

@@ -1,4 +1,4 @@
-import { isSpeakToolName } from "./agent/tool-name-normalization.js";
+import { isSpeakToolName } from "@getpaseo/protocol/tool-name-normalization";
 /** Voice assistant policy: only allow the speak tool. */
 export function isVoicePermissionAllowed(request) {
     if (request.kind !== "tool") {

package/dist/server/server/websocket-server.d.ts

@@ -13,7 +13,7 @@ import type { DaemonConfigStore } from "./daemon-config-store.js";
 import { type ServerCapabilities, type WSOutboundMessage } from "./messages.js";
 import type { HostnamesConfig } from "./hostnames.js";
 import { Session, type SessionLifecycleIntent } from "./session.js";
-import type { AgentProviderRuntimeSettingsMap, ProviderOverride } from "./agent/provider-launch-config.js";
+import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
 import type { WorkspaceGitService } from "./workspace-git-service.js";
 import { type PushNotificationSender } from "./push/notifications.js";
 import type { ScriptHealthState } from "./script-health-monitor.js";
@@ -81,9 +81,6 @@ export declare class VoiceAssistantWebSocketServer {
     private readonly voiceSpeakHandlers;
     private readonly voiceCallerContexts;
     private readonly workspaceSetupSnapshots;
-    private agentProviderRuntimeSettings;
-    private providerOverrides;
-    private isDev;
     private readonly providerSnapshotManager;
     private onLifecycleIntent;
     private onBranchChanged;
@@ -94,7 +91,7 @@ export declare class VoiceAssistantWebSocketServer {
     private unsubscribeDaemonConfigChange;
     constructor(server: HTTPServer, logger: pino.Logger, serverId: string, agentManager: AgentManager, agentStorage: AgentStorage, downloadTokenStore: DownloadTokenStore, paseoHome: string, daemonConfigStore: DaemonConfigStore, mcpBaseUrl: string | null, wsConfig: WebSocketServerConfig, auth?: DaemonAuthConfig, speech?: SpeechService | null, terminalManager?: TerminalManager | null, dictation?: {
         finalTimeoutMs?: number;
-    }, agentProviderRuntimeSettings?: AgentProviderRuntimeSettingsMap, providerOverrides?: Record<string, ProviderOverride>, isDev?: boolean, daemonVersion?: string, onLifecycleIntent?: (intent: SessionLifecycleIntent) => void, projectRegistry?: ProjectRegistry, workspaceRegistry?: WorkspaceRegistry, chatService?: FileBackedChatService, loopService?: LoopService, scheduleService?: ScheduleService, checkoutDiffManager?: CheckoutDiffManager, scriptRouteStore?: ScriptRouteStore | null, scriptRuntimeStore?: WorkspaceScriptRuntimeStore | null, onBranchChanged?: (workspaceId: string, oldBranch: string | null, newBranch: string | null) => void, getDaemonTcpPort?: () => number | null, getDaemonTcpHost?: () => string | null, resolveScriptHealth?: (hostname: string) => ScriptHealthState | null, workspaceGitService?: WorkspaceGitService, github?: GitHubService, pushNotificationSender?: PushNotificationSender, daemonRuntimeConfig?: {
+    }, daemonVersion?: string, onLifecycleIntent?: (intent: SessionLifecycleIntent) => void, projectRegistry?: ProjectRegistry, workspaceRegistry?: WorkspaceRegistry, chatService?: FileBackedChatService, loopService?: LoopService, scheduleService?: ScheduleService, checkoutDiffManager?: CheckoutDiffManager, scriptRouteStore?: ScriptRouteStore | null, scriptRuntimeStore?: WorkspaceScriptRuntimeStore | null, onBranchChanged?: (workspaceId: string, oldBranch: string | null, newBranch: string | null) => void, getDaemonTcpPort?: () => number | null, getDaemonTcpHost?: () => string | null, resolveScriptHealth?: (hostname: string) => ScriptHealthState | null, workspaceGitService?: WorkspaceGitService, github?: GitHubService, pushNotificationSender?: PushNotificationSender, providerSnapshotManager?: ProviderSnapshotManager, daemonRuntimeConfig?: {
         listen: string | null;
         relay: {
             enabled: boolean;