@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/audio.d.ts

@@ -0,0 +1,10 @@
+export declare function parsePcm16MonoWav(buffer: Buffer): {
+    sampleRate: number;
+    pcm16: Buffer;
+};
+export declare function parsePcmRateFromFormat(format: string, fallback?: number | null): number | null;
+export declare function pcm16lePeakAbs(pcm16le: Buffer): number;
+export declare function pcm16leToFloat32(pcm16le: Buffer, gain?: number): Float32Array;
+export declare function float32ToPcm16le(samples: Float32Array): Buffer;
+export declare function chunkBuffer(buffer: Buffer, chunkBytes: number): Buffer[];
+//# sourceMappingURL=audio.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/audio.js

@@ -0,0 +1,101 @@
+export function parsePcm16MonoWav(buffer) {
+    if (buffer.toString("ascii", 0, 4) !== "RIFF" || buffer.toString("ascii", 8, 12) !== "WAVE") {
+        throw new Error("Invalid WAV header");
+    }
+    let offset = 12;
+    let fmt = null;
+    let dataChunk = null;
+    while (offset + 8 <= buffer.length) {
+        const id = buffer.toString("ascii", offset, offset + 4);
+        const size = buffer.readUInt32LE(offset + 4);
+        const payloadStart = offset + 8;
+        const payloadEnd = payloadStart + size;
+        if (payloadEnd > buffer.length) {
+            break;
+        }
+        if (id === "fmt ") {
+            const audioFormat = buffer.readUInt16LE(payloadStart);
+            const channels = buffer.readUInt16LE(payloadStart + 2);
+            const sampleRate = buffer.readUInt32LE(payloadStart + 4);
+            const bitsPerSample = buffer.readUInt16LE(payloadStart + 14);
+            fmt = { audioFormat, channels, sampleRate, bitsPerSample };
+        }
+        else if (id === "data") {
+            dataChunk = buffer.subarray(payloadStart, payloadEnd);
+        }
+        offset = payloadEnd + (size % 2);
+    }
+    if (!fmt || !dataChunk) {
+        throw new Error("Missing WAV fmt/data chunks");
+    }
+    if (fmt.audioFormat !== 1) {
+        throw new Error(`Unsupported WAV encoding (audioFormat=${fmt.audioFormat})`);
+    }
+    if (fmt.channels !== 1 || fmt.bitsPerSample !== 16) {
+        throw new Error(`Unexpected WAV format: channels=${fmt.channels} rate=${fmt.sampleRate} bits=${fmt.bitsPerSample}`);
+    }
+    if (dataChunk.length % 2 !== 0) {
+        throw new Error("WAV PCM16 data length must be even");
+    }
+    return { sampleRate: fmt.sampleRate, pcm16: dataChunk };
+}
+export function parsePcmRateFromFormat(format, fallback = null) {
+    const match = /(?:^|[;,\s])rate\s*=\s*(\d+)(?:$|[;,\s])/i.exec(format);
+    if (!match) {
+        return fallback;
+    }
+    const rate = Number.parseInt(match[1], 10);
+    return Number.isFinite(rate) && rate > 0 ? rate : fallback;
+}
+export function pcm16lePeakAbs(pcm16le) {
+    if (pcm16le.length === 0) {
+        return 0;
+    }
+    if (pcm16le.length % 2 !== 0) {
+        throw new Error(`PCM16 chunk byteLength must be even, got ${pcm16le.length}`);
+    }
+    const samples = new Int16Array(pcm16le.buffer, pcm16le.byteOffset, pcm16le.byteLength / 2);
+    let peak = 0;
+    for (let i = 0; i < samples.length; i += 1) {
+        const v = samples[i];
+        const abs = v < 0 ? -v : v;
+        if (abs > peak) {
+            peak = abs;
+            if (peak >= 32767) {
+                break;
+            }
+        }
+    }
+    return peak;
+}
+export function pcm16leToFloat32(pcm16le, gain = 1) {
+    if (pcm16le.length % 2 !== 0) {
+        throw new Error(`PCM16 chunk byteLength must be even, got ${pcm16le.length}`);
+    }
+    const int16 = new Int16Array(pcm16le.buffer, pcm16le.byteOffset, pcm16le.byteLength / 2);
+    const out = new Float32Array(int16.length);
+    for (let i = 0; i < int16.length; i += 1) {
+        const v = (int16[i] / 32768.0) * gain;
+        out[i] = Math.max(-1, Math.min(1, v));
+    }
+    return out;
+}
+export function float32ToPcm16le(samples) {
+    const out = new Int16Array(samples.length);
+    for (let i = 0; i < samples.length; i += 1) {
+        const clamped = Math.max(-1, Math.min(1, samples[i]));
+        out[i] = Math.round(clamped * 32767);
+    }
+    return Buffer.from(out.buffer, out.byteOffset, out.byteLength);
+}
+export function chunkBuffer(buffer, chunkBytes) {
+    if (chunkBytes <= 0) {
+        return [buffer];
+    }
+    const out = [];
+    for (let offset = 0; offset < buffer.length; offset += chunkBytes) {
+        out.push(buffer.subarray(offset, Math.min(buffer.length, offset + chunkBytes)));
+    }
+    return out;
+}
+//# sourceMappingURL=audio.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/provider-resolver.d.ts

@@ -0,0 +1,3 @@
+export type Resolvable<T> = T | (() => T);
+export declare function toResolver<T>(value: Resolvable<T>): () => T;
+//# sourceMappingURL=provider-resolver.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/provider-resolver.js

@@ -0,0 +1,7 @@
+export function toResolver(value) {
+    if (typeof value === "function") {
+        return value;
+    }
+    return () => value;
+}
+//# sourceMappingURL=provider-resolver.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/providers/local/config.d.ts

@@ -0,0 +1,30 @@
+import type { PersistedConfig } from "../../../persisted-config.js";
+import type { RequestedSpeechProviders } from "../../speech-types.js";
+import { type LocalSpeechModelId, type LocalSttModelId, type LocalTtsModelId } from "./models.js";
+export interface LocalSpeechModelConfig {
+    dictationStt: LocalSttModelId;
+    voiceStt: LocalSttModelId;
+    voiceTts: LocalTtsModelId;
+    voiceTtsSpeakerId?: number;
+    voiceTtsSpeed?: number;
+}
+export interface LocalSpeechProviderConfig {
+    modelsDir: string;
+    models: LocalSpeechModelConfig;
+}
+export interface ResolvedLocalSpeechConfig {
+    local: LocalSpeechProviderConfig | undefined;
+    sttLanguages: LocalSpeechSttLanguageConfig;
+}
+export type { LocalSpeechModelId, LocalSttModelId, LocalTtsModelId };
+export interface LocalSpeechSttLanguageConfig {
+    dictation: string;
+    voice: string;
+}
+export declare function resolveLocalSpeechConfig(params: {
+    byspaceHome: string;
+    env: NodeJS.ProcessEnv;
+    persisted: PersistedConfig;
+    providers: RequestedSpeechProviders;
+}): ResolvedLocalSpeechConfig;
+//# sourceMappingURL=config.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/providers/local/config.js

@@ -0,0 +1,134 @@
+import path from "node:path";
+import { z } from "zod";
+import { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, } from "./models.js";
+const DEFAULT_LOCAL_MODELS_SUBDIR = path.join("models", "local-speech");
+const DEFAULT_STT_LANGUAGE = "en";
+const NumberLikeSchema = z.union([z.number(), z.string().trim().min(1)]);
+const LanguageSchema = z.string().trim().min(1).default(DEFAULT_STT_LANGUAGE);
+const OptionalFiniteNumberSchema = NumberLikeSchema.pipe(z.coerce.number().finite()).optional();
+const OptionalIntegerSchema = NumberLikeSchema.pipe(z.coerce.number().int()).optional();
+const LocalSpeechResolutionSchema = z.object({
+    includeProviderConfig: z.boolean(),
+    modelsDir: z.string().trim().min(1),
+    dictationLocalSttModel: LocalSttModelIdSchema.default(DEFAULT_LOCAL_STT_MODEL),
+    voiceLocalSttModel: LocalSttModelIdSchema.default(DEFAULT_LOCAL_STT_MODEL),
+    voiceLocalTtsModel: LocalTtsModelIdSchema.default(DEFAULT_LOCAL_TTS_MODEL),
+    dictationLanguage: LanguageSchema,
+    voiceLanguage: LanguageSchema,
+    voiceLocalTtsSpeakerId: OptionalIntegerSchema,
+    voiceLocalTtsSpeed: OptionalFiniteNumberSchema,
+});
+function persistedLocalFeatureModel(provider, enabled, model) {
+    if (provider !== "local" || enabled === false) {
+        return undefined;
+    }
+    return model;
+}
+function shouldIncludeLocalProviderConfig(params) {
+    const localRequestedByFeature = (params.providers.dictationStt.enabled !== false &&
+        params.providers.dictationStt.provider === "local") ||
+        (params.providers.voiceStt.enabled !== false &&
+            params.providers.voiceStt.provider === "local") ||
+        (params.providers.voiceTts.enabled !== false && params.providers.voiceTts.provider === "local");
+    return (localRequestedByFeature ||
+        params.env.BYSPACE_LOCAL_MODELS_DIR !== undefined ||
+        params.persisted.providers?.local?.modelsDir !== undefined);
+}
+function firstDefinedValue(values) {
+    for (const value of values) {
+        if (value !== undefined && value !== null) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function firstNonEmptyString(values) {
+    for (const value of values) {
+        const trimmed = value?.trim();
+        if (trimmed) {
+            return trimmed;
+        }
+    }
+    return undefined;
+}
+function buildLocalSpeechLanguageResolutionInput(params) {
+    const { env, persisted } = params;
+    return {
+        dictationLanguage: firstNonEmptyString([
+            env.BYSPACE_DICTATION_LANGUAGE,
+            persisted.features?.dictation?.stt?.language,
+            DEFAULT_STT_LANGUAGE,
+        ]),
+        voiceLanguage: firstNonEmptyString([
+            env.BYSPACE_VOICE_LANGUAGE,
+            env.BYSPACE_DICTATION_LANGUAGE,
+            persisted.features?.voiceMode?.stt?.language,
+            persisted.features?.dictation?.stt?.language,
+            DEFAULT_STT_LANGUAGE,
+        ]),
+    };
+}
+function buildLocalSpeechResolutionInput(params) {
+    const { byspaceHome, env, persisted, providers, includeProviderConfig } = params;
+    return {
+        includeProviderConfig,
+        modelsDir: firstDefinedValue([
+            env.BYSPACE_LOCAL_MODELS_DIR,
+            persisted.providers?.local?.modelsDir,
+            path.join(byspaceHome, DEFAULT_LOCAL_MODELS_SUBDIR),
+        ]),
+        dictationLocalSttModel: firstDefinedValue([
+            env.BYSPACE_DICTATION_LOCAL_STT_MODEL,
+            persistedLocalFeatureModel(providers.dictationStt.provider, providers.dictationStt.enabled, persisted.features?.dictation?.stt?.model),
+            DEFAULT_LOCAL_STT_MODEL,
+        ]),
+        voiceLocalSttModel: firstDefinedValue([
+            env.BYSPACE_VOICE_LOCAL_STT_MODEL,
+            persistedLocalFeatureModel(providers.voiceStt.provider, providers.voiceStt.enabled, persisted.features?.voiceMode?.stt?.model),
+            DEFAULT_LOCAL_STT_MODEL,
+        ]),
+        voiceLocalTtsModel: firstDefinedValue([
+            env.BYSPACE_VOICE_LOCAL_TTS_MODEL,
+            persistedLocalFeatureModel(providers.voiceTts.provider, providers.voiceTts.enabled, persisted.features?.voiceMode?.tts?.model),
+            DEFAULT_LOCAL_TTS_MODEL,
+        ]),
+        ...buildLocalSpeechLanguageResolutionInput({ env, persisted }),
+        voiceLocalTtsSpeakerId: firstDefinedValue([
+            env.BYSPACE_VOICE_LOCAL_TTS_SPEAKER_ID,
+            persisted.features?.voiceMode?.tts?.speakerId,
+        ]),
+        voiceLocalTtsSpeed: firstDefinedValue([
+            env.BYSPACE_VOICE_LOCAL_TTS_SPEED,
+            persisted.features?.voiceMode?.tts?.speed,
+        ]),
+    };
+}
+export function resolveLocalSpeechConfig(params) {
+    const includeProviderConfig = shouldIncludeLocalProviderConfig(params);
+    const parsed = LocalSpeechResolutionSchema.parse(buildLocalSpeechResolutionInput({ ...params, includeProviderConfig }));
+    const resolvedVoiceTtsSpeakerId = parsed.voiceLocalTtsSpeakerId ??
+        (parsed.voiceLocalTtsModel === "kokoro-en-v0_19" ? 0 : undefined);
+    return {
+        sttLanguages: {
+            dictation: parsed.dictationLanguage,
+            voice: parsed.voiceLanguage,
+        },
+        local: parsed.includeProviderConfig
+            ? {
+                modelsDir: parsed.modelsDir,
+                models: {
+                    dictationStt: parsed.dictationLocalSttModel,
+                    voiceStt: parsed.voiceLocalSttModel,
+                    voiceTts: parsed.voiceLocalTtsModel,
+                    ...(resolvedVoiceTtsSpeakerId !== undefined
+                        ? { voiceTtsSpeakerId: resolvedVoiceTtsSpeakerId }
+                        : {}),
+                    ...(parsed.voiceLocalTtsSpeed !== undefined
+                        ? { voiceTtsSpeed: parsed.voiceLocalTtsSpeed }
+                        : {}),
+                },
+            }
+            : undefined,
+    };
+}
+//# sourceMappingURL=config.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/providers/local/models.d.ts

@@ -0,0 +1,11 @@
+import { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, listSherpaOnnxModels, type LocalSpeechModelId, type LocalSttModelId, type LocalTtsModelId } from "./sherpa/model-catalog.js";
+export { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, type LocalSpeechModelId, type LocalSttModelId, type LocalTtsModelId, };
+export type LocalSpeechModelSpec = ReturnType<typeof listSherpaOnnxModels>[number];
+export declare function listLocalSpeechModels(): LocalSpeechModelSpec[];
+export declare function getLocalSpeechModelDir(modelsDir: string, modelId: LocalSpeechModelId): string;
+export declare function ensureLocalSpeechModels(options: {
+    modelsDir: string;
+    modelIds: LocalSpeechModelId[];
+    logger: import("pino").Logger;
+}): Promise<Record<LocalSpeechModelId, string>>;
+//# sourceMappingURL=models.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/providers/local/models.js

@@ -0,0 +1,17 @@
+import { ensureSherpaOnnxModels, getSherpaOnnxModelDir } from "./sherpa/model-downloader.js";
+import { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, listSherpaOnnxModels, } from "./sherpa/model-catalog.js";
+export { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, };
+export function listLocalSpeechModels() {
+    return listSherpaOnnxModels();
+}
+export function getLocalSpeechModelDir(modelsDir, modelId) {
+    return getSherpaOnnxModelDir(modelsDir, modelId);
+}
+export async function ensureLocalSpeechModels(options) {
+    return ensureSherpaOnnxModels({
+        modelsDir: options.modelsDir,
+        modelIds: options.modelIds,
+        logger: options.logger,
+    });
+}
+//# sourceMappingURL=models.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/providers/local/runtime.d.ts

@@ -0,0 +1,31 @@
+import type { Logger } from "pino";
+import type { BySpaceSpeechConfig } from "../../../bootstrap.js";
+import type { SpeechToTextProvider, TextToSpeechProvider } from "../../speech-provider.js";
+import type { RequestedSpeechProviders } from "../../speech-types.js";
+import type { TurnDetectionProvider } from "../../turn-detection-provider.js";
+import { type LocalSpeechModelId } from "./models.js";
+interface LocalSpeechAvailability {
+    configured: boolean;
+    modelsDir: string | null;
+}
+export interface InitializedLocalSpeech {
+    turnDetectionService: TurnDetectionProvider | null;
+    sttService: SpeechToTextProvider | null;
+    ttsService: TextToSpeechProvider | null;
+    dictationSttService: SpeechToTextProvider | null;
+    localVoiceTtsProvider: TextToSpeechProvider | null;
+    localModelConfig: {
+        modelsDir: string;
+        defaultModelIds: LocalSpeechModelId[];
+    } | null;
+    availability: LocalSpeechAvailability;
+    cleanup: () => void;
+}
+export declare function getLocalSpeechAvailability(speechConfig: BySpaceSpeechConfig | null): LocalSpeechAvailability;
+export declare function initializeLocalSpeechServices(params: {
+    providers: RequestedSpeechProviders;
+    speechConfig: BySpaceSpeechConfig | null;
+    logger: Logger;
+}): Promise<InitializedLocalSpeech>;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/providers/local/runtime.js

@@ -0,0 +1,135 @@
+import { DEFAULT_LOCAL_STT_MODEL, DEFAULT_LOCAL_TTS_MODEL, LocalSttModelIdSchema, LocalTtsModelIdSchema, } from "./models.js";
+import { LocalSpeechWorkerClient, WorkerBackedSpeechToTextProvider, WorkerBackedTextToSpeechProvider, WorkerBackedTurnDetectionProvider, } from "./worker-client.js";
+function resolveConfiguredLocalModels(speechConfig) {
+    return {
+        dictationLocalSttModel: LocalSttModelIdSchema.parse(speechConfig?.local?.models.dictationStt ?? DEFAULT_LOCAL_STT_MODEL),
+        voiceLocalSttModel: LocalSttModelIdSchema.parse(speechConfig?.local?.models.voiceStt ?? DEFAULT_LOCAL_STT_MODEL),
+        voiceLocalTtsModel: LocalTtsModelIdSchema.parse(speechConfig?.local?.models.voiceTts ?? DEFAULT_LOCAL_TTS_MODEL),
+    };
+}
+export function getLocalSpeechAvailability(speechConfig) {
+    const localConfig = speechConfig?.local ?? null;
+    return {
+        configured: Boolean(localConfig),
+        modelsDir: localConfig?.modelsDir ?? null,
+    };
+}
+function computeRequiredLocalModelIds(params) {
+    const ids = new Set();
+    if (params.providers.dictationStt.enabled !== false &&
+        params.providers.dictationStt.provider === "local") {
+        ids.add(params.models.dictationLocalSttModel);
+    }
+    if (params.providers.voiceStt.enabled !== false &&
+        params.providers.voiceStt.provider === "local") {
+        ids.add(params.models.voiceLocalSttModel);
+    }
+    if (params.providers.voiceTts.enabled !== false &&
+        params.providers.voiceTts.provider === "local") {
+        ids.add(params.models.voiceLocalTtsModel);
+    }
+    return Array.from(ids);
+}
+function isLocalProviderEnabled(provider) {
+    return provider.enabled !== false && provider.provider === "local";
+}
+function warnLocalConfigMissing(logger, feature) {
+    logger.warn({ configured: false }, `Local ${feature} selected but local provider config is missing; ${feature} will be unavailable`);
+}
+function initializeLocalTurnDetection(params) {
+    const { client } = params;
+    return new WorkerBackedTurnDetectionProvider(client);
+}
+function initializeLocalVoiceStt(params) {
+    const { client } = params;
+    return new WorkerBackedSpeechToTextProvider(client, "voiceStt");
+}
+function initializeLocalDictationStt(params) {
+    const { client } = params;
+    return new WorkerBackedSpeechToTextProvider(client, "dictationStt");
+}
+function initializeLocalVoiceTts(params) {
+    const { client } = params;
+    return new WorkerBackedTextToSpeechProvider(client);
+}
+export async function initializeLocalSpeechServices(params) {
+    const { providers, logger, speechConfig } = params;
+    const localConfig = speechConfig?.local ?? null;
+    const localModels = resolveConfiguredLocalModels(speechConfig);
+    let sttService = null;
+    let ttsService = null;
+    let dictationSttService = null;
+    let turnDetectionService = null;
+    let localVoiceTtsProvider = null;
+    const requiredLocalModelIds = computeRequiredLocalModelIds({
+        providers,
+        models: localModels,
+    });
+    const workerClient = localConfig
+        ? new LocalSpeechWorkerClient({
+            logger,
+            config: {
+                modelsDir: localConfig.modelsDir,
+                voiceSttModel: localModels.voiceLocalSttModel,
+                dictationSttModel: localModels.dictationLocalSttModel,
+                voiceTtsModel: localModels.voiceLocalTtsModel,
+                voiceTtsSpeakerId: speechConfig?.local?.models.voiceTtsSpeakerId,
+                voiceTtsSpeed: speechConfig?.local?.models.voiceTtsSpeed,
+            },
+        })
+        : null;
+    if (isLocalProviderEnabled(providers.voiceTurnDetection)) {
+        if (workerClient) {
+            turnDetectionService = initializeLocalTurnDetection({ client: workerClient });
+        }
+        else {
+            warnLocalConfigMissing(logger, "turn detection");
+        }
+    }
+    if (isLocalProviderEnabled(providers.voiceStt)) {
+        if (workerClient) {
+            sttService = initializeLocalVoiceStt({ client: workerClient });
+        }
+        else {
+            warnLocalConfigMissing(logger, "voice STT");
+        }
+    }
+    if (isLocalProviderEnabled(providers.dictationStt)) {
+        if (workerClient) {
+            dictationSttService = initializeLocalDictationStt({ client: workerClient });
+        }
+        else {
+            warnLocalConfigMissing(logger, "dictation STT");
+        }
+    }
+    if (isLocalProviderEnabled(providers.voiceTts)) {
+        if (workerClient) {
+            localVoiceTtsProvider = initializeLocalVoiceTts({ client: workerClient });
+        }
+        else {
+            warnLocalConfigMissing(logger, "voice TTS");
+        }
+        if (localVoiceTtsProvider) {
+            ttsService = localVoiceTtsProvider;
+        }
+    }
+    const cleanup = () => {
+        workerClient?.shutdown();
+    };
+    return {
+        turnDetectionService,
+        sttService,
+        ttsService,
+        dictationSttService,
+        localVoiceTtsProvider,
+        localModelConfig: localConfig
+            ? {
+                modelsDir: localConfig.modelsDir,
+                defaultModelIds: requiredLocalModelIds,
+            }
+            : null,
+        availability: getLocalSpeechAvailability(speechConfig),
+        cleanup,
+    };
+}
+//# sourceMappingURL=runtime.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/providers/local/sherpa/model-catalog.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+export type SherpaOnnxModelKind = "stt-offline" | "tts";
+type DefaultModelRole = "stt" | "tts";
+interface SherpaOnnxCatalogEntry {
+    kind: SherpaOnnxModelKind;
+    archiveUrl: string;
+    extractedDir: string;
+    requiredFiles: string[];
+    description: string;
+    defaultFor?: DefaultModelRole;
+}
+export declare const SHERPA_ONNX_MODEL_CATALOG: {
+    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 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, 25 European languages, auto-detected).";
+    };
+    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 defaultFor: "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-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: "kokoro-en-v0_19";
+export declare const LocalSttModelIdSchema: z.ZodType<LocalSttModelId, string, z.core.$ZodTypeInternals<LocalSttModelId, string>>;
+export declare const LocalTtsModelIdSchema: z.ZodType<"kokoro-en-v0_19", string, z.core.$ZodTypeInternals<"kokoro-en-v0_19", string>>;
+export type SherpaOnnxModelSpec = SherpaOnnxCatalogEntry & {
+    id: SherpaOnnxModelId;
+};
+export declare function listSherpaOnnxModels(): SherpaOnnxModelSpec[];
+export declare function getSherpaOnnxModelSpec(id: SherpaOnnxModelId): SherpaOnnxModelSpec;
+export {};
+//# sourceMappingURL=model-catalog.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/providers/local/sherpa/model-catalog.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+export const SHERPA_ONNX_MODEL_CATALOG = {
+    "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).",
+        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, 25 European languages, auto-detected).",
+    },
+    "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).",
+        defaultFor: "tts",
+    },
+};
+const ALL_MODEL_IDS = Object.keys(SHERPA_ONNX_MODEL_CATALOG).filter((k) => k in SHERPA_ONNX_MODEL_CATALOG);
+function isLocalSttModelId(id) {
+    return SHERPA_ONNX_MODEL_CATALOG[id].kind !== "tts";
+}
+function isLocalTtsModelId(id) {
+    return SHERPA_ONNX_MODEL_CATALOG[id].kind === "tts";
+}
+export const LOCAL_STT_MODEL_IDS = ALL_MODEL_IDS.filter(isLocalSttModelId);
+export const LOCAL_TTS_MODEL_IDS = ALL_MODEL_IDS.filter(isLocalTtsModelId);
+function resolveDefaultModelId(role) {
+    const match = ALL_MODEL_IDS.find((id) => {
+        const entry = SHERPA_ONNX_MODEL_CATALOG[id];
+        return entry.defaultFor === role;
+    });
+    if (!match) {
+        throw new Error(`No default model configured for role '${role}'`);
+    }
+    return match;
+}
+export const DEFAULT_LOCAL_STT_MODEL = resolveDefaultModelId("stt");
+export const DEFAULT_LOCAL_TTS_MODEL = resolveDefaultModelId("tts");
+function createModelIdSchema(modelIds) {
+    const validIds = new Set(modelIds);
+    return z
+        .string()
+        .trim()
+        .toLowerCase()
+        .refine((value) => validIds.has(value), {
+        message: "Invalid model id",
+    })
+        .transform((value) => value);
+}
+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]));
+}
+export function getSherpaOnnxModelSpec(id) {
+    const spec = SHERPA_ONNX_MODEL_CATALOG[id];
+    if (!spec) {
+        throw new Error(`Unknown local speech model id: ${id}`);
+    }
+    return {
+        id,
+        ...spec,
+    };
+}
+//# sourceMappingURL=model-catalog.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/speech/providers/local/sherpa/model-downloader.d.ts

@@ -0,0 +1,15 @@
+import type pino from "pino";
+import { type SherpaOnnxModelId } from "./model-catalog.js";
+export interface EnsureSherpaOnnxModelOptions {
+    modelsDir: string;
+    modelId: SherpaOnnxModelId;
+    logger: pino.Logger;
+}
+export declare function getSherpaOnnxModelDir(modelsDir: string, modelId: SherpaOnnxModelId): string;
+export declare function ensureSherpaOnnxModel(options: EnsureSherpaOnnxModelOptions): Promise<string>;
+export declare function ensureSherpaOnnxModels(options: {
+    modelsDir: string;
+    modelIds: SherpaOnnxModelId[];
+    logger: pino.Logger;
+}): Promise<Record<SherpaOnnxModelId, string>>;
+//# sourceMappingURL=model-downloader.d.ts.map