@otto-code/server 0.5.0

package/dist/server/server/speech/providers/local/sherpa/sherpa-parakeet-realtime-session.js

@@ -0,0 +1,137 @@
+import { EventEmitter } from "node:events";
+import { v4 as uuidv4 } from "uuid";
+import { pcm16lePeakAbs, pcm16leToFloat32 } from "../../../audio.js";
+export class SherpaParakeetRealtimeTranscriptionSession extends EventEmitter {
+    constructor(params) {
+        super();
+        this.connected = false;
+        this.currentSegmentId = null;
+        this.previousSegmentId = null;
+        this.lastPartialText = "";
+        this.pcm16 = Buffer.alloc(0);
+        this.lastDecodeAt = 0;
+        this.decoding = false;
+        this.pendingDecode = false;
+        this.engine = params.engine;
+        this.requiredSampleRate = this.engine.sampleRate;
+        this.minDecodeIntervalMs = params.minDecodeIntervalMs ?? 350;
+    }
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        this.currentSegmentId = uuidv4();
+        this.connected = true;
+    }
+    appendPcm16(chunk) {
+        if (!this.connected || !this.currentSegmentId) {
+            this.emit("error", new Error("Parakeet realtime session not connected"));
+            return;
+        }
+        try {
+            this.pcm16 = this.pcm16.length === 0 ? chunk : Buffer.concat([this.pcm16, chunk]);
+            void this.maybeDecode(false);
+        }
+        catch (err) {
+            this.emit("error", err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    commit() {
+        if (!this.connected || !this.currentSegmentId) {
+            this.emit("error", new Error("Parakeet realtime session not connected"));
+            return;
+        }
+        void (async () => {
+            try {
+                await this.maybeDecode(true);
+                const finalText = this.lastPartialText;
+                const segmentId = this.currentSegmentId;
+                const previousSegmentId = this.previousSegmentId;
+                this.emit("committed", { segmentId, previousSegmentId });
+                this.emit("transcript", { segmentId, transcript: finalText, isFinal: true });
+                this.previousSegmentId = segmentId;
+                this.currentSegmentId = uuidv4();
+                this.lastPartialText = "";
+                this.pcm16 = Buffer.alloc(0);
+            }
+            catch (err) {
+                this.emit("error", err instanceof Error ? err : new Error(String(err)));
+            }
+        })();
+    }
+    clear() {
+        if (!this.connected) {
+            return;
+        }
+        this.pcm16 = Buffer.alloc(0);
+        this.currentSegmentId = uuidv4();
+        this.lastPartialText = "";
+    }
+    close() {
+        this.connected = false;
+        this.currentSegmentId = null;
+        this.pcm16 = Buffer.alloc(0);
+    }
+    async maybeDecode(force) {
+        if (!this.connected || !this.currentSegmentId) {
+            return;
+        }
+        const now = Date.now();
+        if (!force && now - this.lastDecodeAt < this.minDecodeIntervalMs) {
+            return;
+        }
+        if (this.decoding) {
+            this.pendingDecode = true;
+            return;
+        }
+        this.decoding = true;
+        try {
+            const text = await this.decodeNow();
+            this.lastDecodeAt = Date.now();
+            if (text !== this.lastPartialText) {
+                this.lastPartialText = text;
+                this.emit("transcript", {
+                    segmentId: this.currentSegmentId,
+                    transcript: text,
+                    isFinal: false,
+                });
+            }
+        }
+        finally {
+            this.decoding = false;
+            if (this.pendingDecode) {
+                this.pendingDecode = false;
+                await this.maybeDecode(true);
+            }
+        }
+    }
+    async decodeNow() {
+        if (this.pcm16.length === 0) {
+            return "";
+        }
+        const peak = pcm16lePeakAbs(this.pcm16);
+        const peakFloat = peak / 32768.0;
+        const targetPeak = 0.6;
+        const maxGain = 50;
+        const gain = peakFloat > 0 && peakFloat < targetPeak ? Math.min(maxGain, targetPeak / peakFloat) : 1;
+        const stream = this.engine.createStream();
+        try {
+            const floatSamples = pcm16leToFloat32(this.pcm16, gain);
+            this.engine.acceptWaveform(stream, this.engine.sampleRate, floatSamples);
+            this.engine.recognizer.decode(stream);
+            const result = this.engine.recognizer.getResult(stream);
+            return String((typeof result === "object" && result && "text" in result ? result.text : undefined) ??
+                result ??
+                "").trim();
+        }
+        finally {
+            try {
+                stream.free?.();
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}
+//# sourceMappingURL=sherpa-parakeet-realtime-session.js.map

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

@@ -0,0 +1,21 @@
+import type pino from "pino";
+import type { SpeechToTextProvider, StreamingTranscriptionSession, TranscriptionResult } from "../../../speech-provider.js";
+import { SherpaOfflineRecognizerEngine } from "./sherpa-offline-recognizer.js";
+export interface SherpaParakeetSttConfig {
+    engine: SherpaOfflineRecognizerEngine;
+    silencePeakThreshold?: number;
+}
+export declare class SherpaOnnxParakeetSTT implements SpeechToTextProvider {
+    private readonly engine;
+    private readonly silencePeakThreshold;
+    private readonly logger;
+    readonly id: "local";
+    constructor(config: SherpaParakeetSttConfig, logger: pino.Logger);
+    createSession(params: {
+        logger: pino.Logger;
+        language?: string;
+        prompt?: string;
+    }): StreamingTranscriptionSession;
+    transcribeAudio(audioBuffer: Buffer, format: string): Promise<TranscriptionResult>;
+}
+//# sourceMappingURL=sherpa-parakeet-stt.d.ts.map

package/dist/server/server/speech/providers/local/sherpa/sherpa-parakeet-stt.js

@@ -0,0 +1,133 @@
+import { EventEmitter } from "node:events";
+import { v4 as uuidv4 } from "uuid";
+import { Pcm16MonoResampler } from "../../../../agent/pcm16-resampler.js";
+import { parsePcm16MonoWav, parsePcmRateFromFormat, pcm16lePeakAbs, pcm16leToFloat32, } from "../../../audio.js";
+export class SherpaOnnxParakeetSTT {
+    constructor(config, logger) {
+        this.id = "local";
+        this.engine = config.engine;
+        this.silencePeakThreshold = config.silencePeakThreshold ?? 300;
+        this.logger = logger.child({ module: "speech", provider: "local", component: "parakeet-stt" });
+    }
+    createSession(params) {
+        const emitter = new EventEmitter();
+        const logger = params.logger.child({ provider: "local", component: "parakeet-stt-session" });
+        const requiredSampleRate = this.engine.sampleRate;
+        let connected = false;
+        let segmentId = uuidv4();
+        let previousSegmentId = null;
+        let pcm16 = Buffer.alloc(0);
+        return {
+            requiredSampleRate,
+            async connect() {
+                connected = true;
+            },
+            appendPcm16(chunk) {
+                if (!connected) {
+                    emitter.emit("error", new Error("STT session not connected"));
+                    return;
+                }
+                pcm16 = pcm16.length === 0 ? chunk : Buffer.concat([pcm16, chunk]);
+            },
+            commit: () => {
+                if (!connected) {
+                    emitter.emit("error", new Error("STT session not connected"));
+                    return;
+                }
+                const committedId = segmentId;
+                const prev = previousSegmentId;
+                const committedPcm16 = pcm16;
+                previousSegmentId = committedId;
+                segmentId = uuidv4();
+                pcm16 = Buffer.alloc(0);
+                emitter.emit("committed", { segmentId: committedId, previousSegmentId: prev });
+                void (async () => {
+                    try {
+                        const rt = await this.transcribeAudio(committedPcm16, `audio/pcm;rate=${requiredSampleRate}`);
+                        emitter.emit("transcript", {
+                            segmentId: committedId,
+                            transcript: rt.text,
+                            isFinal: true,
+                            language: rt.language,
+                            logprobs: rt.logprobs,
+                            avgLogprob: rt.avgLogprob,
+                            isLowConfidence: rt.isLowConfidence,
+                        });
+                    }
+                    catch (err) {
+                        emitter.emit("error", err);
+                    }
+                    finally {
+                        logger.debug({ bytes: committedPcm16.length }, "Parakeet session reset");
+                    }
+                })();
+            },
+            clear() {
+                pcm16 = Buffer.alloc(0);
+                segmentId = uuidv4();
+            },
+            close() {
+                connected = false;
+                pcm16 = Buffer.alloc(0);
+            },
+            on(event, handler) {
+                emitter.on(event, handler);
+                return undefined;
+            },
+        };
+    }
+    async transcribeAudio(audioBuffer, format) {
+        const start = Date.now();
+        let inputRate;
+        let pcm16;
+        if (format.toLowerCase().includes("audio/wav")) {
+            const parsed = parsePcm16MonoWav(audioBuffer);
+            inputRate = parsed.sampleRate;
+            pcm16 = parsed.pcm16;
+        }
+        else if (format.toLowerCase().includes("audio/pcm")) {
+            inputRate = parsePcmRateFromFormat(format, this.engine.sampleRate) ?? this.engine.sampleRate;
+            pcm16 = audioBuffer;
+        }
+        else {
+            throw new Error(`Unsupported audio format for sherpa Parakeet STT: ${format}`);
+        }
+        const peak = pcm16lePeakAbs(pcm16);
+        if (peak < this.silencePeakThreshold) {
+            return { text: "", duration: Date.now() - start, isLowConfidence: true };
+        }
+        let pcmForModel = pcm16;
+        if (inputRate !== this.engine.sampleRate) {
+            const resampler = new Pcm16MonoResampler({ inputRate, outputRate: this.engine.sampleRate });
+            pcmForModel = resampler.processChunk(pcm16);
+            inputRate = this.engine.sampleRate;
+        }
+        const peakForModel = pcm16lePeakAbs(pcmForModel);
+        const peakFloat = peakForModel / 32768.0;
+        const targetPeak = 0.6;
+        const maxGain = 50;
+        const gain = peakFloat > 0 && peakFloat < targetPeak ? Math.min(maxGain, targetPeak / peakFloat) : 1;
+        const stream = this.engine.createStream();
+        try {
+            const floatSamples = pcm16leToFloat32(pcmForModel, gain);
+            this.engine.acceptWaveform(stream, inputRate, floatSamples);
+            this.engine.recognizer.decode(stream);
+            const result = this.engine.recognizer.getResult(stream);
+            const text = String((typeof result === "object" && result && "text" in result ? result.text : undefined) ??
+                result ??
+                "").trim();
+            const duration = Date.now() - start;
+            this.logger.debug({ duration, textLength: text.length }, "Parakeet transcription complete");
+            return { text, duration, ...(text.length === 0 ? { isLowConfidence: true } : {}) };
+        }
+        finally {
+            try {
+                stream.free?.();
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}
+//# sourceMappingURL=sherpa-parakeet-stt.js.map

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

@@ -0,0 +1,18 @@
+export type SherpaLoaderEnvKey = "LD_LIBRARY_PATH" | "DYLD_LIBRARY_PATH" | "PATH";
+export interface SherpaLoaderEnvResolution {
+    key: SherpaLoaderEnvKey;
+    libDir: string;
+    packageName: string;
+}
+export declare function sherpaPlatformArch(platform?: NodeJS.Platform, arch?: string): string;
+export declare function sherpaPlatformPackageName(platform?: NodeJS.Platform, arch?: string): string;
+export declare function sherpaLoaderEnvKey(platform?: NodeJS.Platform): SherpaLoaderEnvKey | null;
+export declare function prependEnvPath(existing: string | undefined, value: string): string;
+export declare function resolveSherpaLoaderEnv(platform?: NodeJS.Platform, arch?: string): SherpaLoaderEnvResolution | null;
+export declare function applySherpaLoaderEnv(env: NodeJS.ProcessEnv, platform?: NodeJS.Platform, arch?: string): {
+    changed: boolean;
+    key: SherpaLoaderEnvKey | null;
+    libDir: string | null;
+    packageName: string | null;
+};
+//# sourceMappingURL=sherpa-runtime-env.d.ts.map

package/dist/server/server/speech/providers/local/sherpa/sherpa-runtime-env.js

@@ -0,0 +1,84 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+export function sherpaPlatformArch(platform = process.platform, arch = process.arch) {
+    const normalizedPlatform = platform === "win32" ? "win" : platform;
+    return `${normalizedPlatform}-${arch}`;
+}
+export function sherpaPlatformPackageName(platform = process.platform, arch = process.arch) {
+    return `sherpa-onnx-${sherpaPlatformArch(platform, arch)}`;
+}
+export function sherpaLoaderEnvKey(platform = process.platform) {
+    if (platform === "linux") {
+        return "LD_LIBRARY_PATH";
+    }
+    if (platform === "darwin") {
+        return "DYLD_LIBRARY_PATH";
+    }
+    if (platform === "win32") {
+        return "PATH";
+    }
+    return null;
+}
+export function prependEnvPath(existing, value) {
+    const parts = (existing ?? "").split(path.delimiter).filter(Boolean);
+    if (parts.includes(value)) {
+        return parts.join(path.delimiter);
+    }
+    return [value, ...parts].join(path.delimiter);
+}
+export function resolveSherpaLoaderEnv(platform = process.platform, arch = process.arch) {
+    const key = sherpaLoaderEnvKey(platform);
+    if (!key) {
+        return null;
+    }
+    const packageName = sherpaPlatformPackageName(platform, arch);
+    const require = createRequire(import.meta.url);
+    try {
+        const pkgJson = require.resolve(`${packageName}/package.json`);
+        return {
+            key,
+            libDir: path.dirname(pkgJson),
+            packageName,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find the actual case-sensitive key in a plain object that matches the given
+ * key case-insensitively. On Windows, `{...process.env}` produces a plain
+ * (case-sensitive) object where PATH is typically stored as `Path`. Using a
+ * hardcoded `"PATH"` would miss the existing key and create a duplicate,
+ * breaking the child process's PATH.
+ */
+function findEnvKey(env, key) {
+    const lower = key.toLowerCase();
+    for (const k of Object.keys(env)) {
+        if (k.toLowerCase() === lower)
+            return k;
+    }
+    return key;
+}
+export function applySherpaLoaderEnv(env, platform = process.platform, arch = process.arch) {
+    const resolved = resolveSherpaLoaderEnv(platform, arch);
+    if (!resolved) {
+        return {
+            changed: false,
+            key: null,
+            libDir: null,
+            packageName: null,
+        };
+    }
+    const actualKey = findEnvKey(env, resolved.key);
+    const next = prependEnvPath(env[actualKey], resolved.libDir);
+    const changed = next !== (env[actualKey] ?? "");
+    env[actualKey] = next;
+    return {
+        changed,
+        key: resolved.key,
+        libDir: resolved.libDir,
+        packageName: resolved.packageName,
+    };
+}
+//# sourceMappingURL=sherpa-runtime-env.js.map

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

@@ -0,0 +1,24 @@
+import type pino from "pino";
+import type { SpeechStreamResult, SpeechVoiceOverride, TextToSpeechProvider } from "../../../speech-provider.js";
+import { type LocalTtsModelId } from "./model-catalog.js";
+export type SherpaTtsPreset = LocalTtsModelId;
+export interface SherpaTtsConfig {
+    preset: SherpaTtsPreset;
+    modelDir: string;
+    speakerId?: number;
+    speed?: number;
+    lengthScale?: number;
+    numThreads?: number;
+}
+export declare class SherpaOnnxTTS implements TextToSpeechProvider {
+    private readonly tts;
+    private readonly preset;
+    private readonly speakerId;
+    private readonly speed;
+    private readonly logger;
+    constructor(config: SherpaTtsConfig, logger: pino.Logger);
+    private resolveSpeakerId;
+    synthesizeSpeech(text: string, voice?: SpeechVoiceOverride): Promise<SpeechStreamResult>;
+    free(): void;
+}
+//# sourceMappingURL=sherpa-tts.d.ts.map

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

@@ -0,0 +1,145 @@
+import { Readable } from "node:stream";
+import { existsSync } from "node:fs";
+import { chunkBuffer, float32ToPcm16le } from "../../../audio.js";
+import { getSherpaOnnxTtsLayout } from "./model-catalog.js";
+import { listLocalTtsVoices, resolveLocalTtsSpeakerId } from "./tts-voices.js";
+import { loadSherpaOnnxNode } from "./sherpa-onnx-node-loader.js";
+// sherpa-onnx will crash the native worker on a nonsensical speed or an
+// out-of-range speaker id. These bounds fence off bad persisted/env config
+// (e.g. speed=0 or speakerId=999) before it reaches generate().
+const MIN_TTS_SPEED = 0.5;
+const MAX_TTS_SPEED = 2.0;
+function clampTtsSpeed(speed) {
+    if (speed === undefined || !Number.isFinite(speed)) {
+        return 1.0;
+    }
+    return Math.min(MAX_TTS_SPEED, Math.max(MIN_TTS_SPEED, speed));
+}
+function resolveValidSpeakerId(preset, requested, fallback) {
+    if (requested === undefined) {
+        return fallback;
+    }
+    const voiceCount = listLocalTtsVoices(preset).length;
+    if (Number.isInteger(requested) && requested >= 0 && requested < voiceCount) {
+        return requested;
+    }
+    return fallback;
+}
+function assertFileExists(filePath, label) {
+    if (!existsSync(filePath)) {
+        throw new Error(`Missing ${label}: ${filePath}`);
+    }
+}
+export class SherpaOnnxTTS {
+    constructor(config, logger) {
+        this.logger = logger.child({ module: "speech", provider: "local", component: "tts" });
+        const layout = getSherpaOnnxTtsLayout(config.preset);
+        this.preset = config.preset;
+        this.speakerId = resolveValidSpeakerId(config.preset, config.speakerId, layout.defaultSpeakerId);
+        if (config.speakerId !== undefined && config.speakerId !== this.speakerId) {
+            this.logger.warn({ requested: config.speakerId, fallback: this.speakerId, preset: config.preset }, "Configured TTS speaker id is out of range; falling back to the model default");
+        }
+        this.speed = clampTtsSpeed(config.speed);
+        const sherpa = loadSherpaOnnxNode();
+        if (typeof sherpa.OfflineTts !== "function") {
+            throw new Error("sherpa-onnx-node OfflineTts is unavailable");
+        }
+        const modelPath = `${config.modelDir}/${layout.modelFile}`;
+        const voicesPath = `${config.modelDir}/voices.bin`;
+        const tokensPath = `${config.modelDir}/tokens.txt`;
+        const dataDir = `${config.modelDir}/espeak-ng-data`;
+        const lexiconPaths = layout.lexiconFiles.map((file) => `${config.modelDir}/${file}`);
+        assertFileExists(modelPath, "TTS model");
+        assertFileExists(voicesPath, "TTS voices");
+        assertFileExists(tokensPath, "TTS tokens");
+        assertFileExists(dataDir, "TTS espeak-ng dataDir");
+        for (const lexiconPath of lexiconPaths) {
+            assertFileExists(lexiconPath, "TTS lexicon");
+        }
+        const modelConfig = {
+            kokoro: {
+                model: modelPath,
+                voices: voicesPath,
+                tokens: tokensPath,
+                dataDir,
+                // Kokoro v1.x ships lexicons for EN/ZH; other languages fall back to
+                // espeak-ng phonemes from dataDir. v0.19 has no lexicon files.
+                ...(lexiconPaths.length > 0 ? { lexicon: lexiconPaths.join(",") } : {}),
+                lengthScale: config.lengthScale ?? 1.0,
+            },
+        };
+        const offlineTtsConfig = {
+            model: modelConfig,
+            numThreads: config.numThreads ?? 2,
+            provider: "cpu",
+            maxNumSentences: 1,
+        };
+        this.tts = new sherpa.OfflineTts(offlineTtsConfig);
+        this.logger.info({ preset: config.preset, modelDir: config.modelDir }, "Sherpa offline TTS initialized");
+    }
+    // A personality voice only resolves to a speaker on THIS model. A voice bound
+    // to a different model (or an unknown name) silently falls back to the host
+    // default — the personality voice is a soft binding, never a hard failure.
+    resolveSpeakerId(voice) {
+        if (!voice || (voice.model && voice.model !== this.preset)) {
+            return this.speakerId;
+        }
+        return resolveLocalTtsSpeakerId(this.preset, voice.name) ?? this.speakerId;
+    }
+    async synthesizeSpeech(text, voice) {
+        const trimmed = text.trim();
+        if (!trimmed) {
+            throw new Error("Cannot synthesize empty text");
+        }
+        const audio = this.tts.generate({
+            text: trimmed,
+            sid: this.resolveSpeakerId(voice),
+            speed: this.speed,
+            // Electron rejects native external-backed typed arrays. Request a copied buffer
+            // from sherpa itself instead of trying to clone after generate() returns.
+            enableExternalBuffer: false,
+        });
+        let rawSamples = null;
+        if (audio && audio.samples instanceof Float32Array) {
+            rawSamples = audio.samples;
+        }
+        else if (audio && Array.isArray(audio.samples)) {
+            rawSamples = Float32Array.from(audio.samples);
+        }
+        // Copy to avoid "External buffers are not allowed" when sherpa-onnx
+        // returns a Float32Array backed by native memory.
+        const samples = rawSamples ? Float32Array.from(rawSamples) : null;
+        let sampleRate;
+        if (audio &&
+            typeof audio.sampleRate === "number" &&
+            Number.isFinite(audio.sampleRate) &&
+            audio.sampleRate > 0) {
+            sampleRate = audio.sampleRate;
+        }
+        else if (typeof this.tts.sampleRate === "number") {
+            sampleRate = this.tts.sampleRate;
+        }
+        else {
+            sampleRate = 24000;
+        }
+        if (!samples) {
+            throw new Error("Unexpected sherpa TTS output: missing Float32 samples");
+        }
+        const pcm16 = float32ToPcm16le(samples);
+        const chunkBytes = Math.max(2, Math.round(sampleRate * 0.05) * 2); // ~50ms
+        const chunks = chunkBuffer(pcm16, chunkBytes);
+        return {
+            stream: Readable.from(chunks),
+            format: `pcm;rate=${sampleRate}`,
+        };
+    }
+    free() {
+        try {
+            this.tts?.free?.();
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+//# sourceMappingURL=sherpa-tts.js.map

package/dist/server/server/speech/providers/local/sherpa/silero-vad-provider.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from "pino";
+import type { TurnDetectionProvider, TurnDetectionSession } from "../../../turn-detection-provider.js";
+import { type SherpaSileroVadSessionConfig } from "./silero-vad-session.js";
+/**
+ * Ensure the Silero VAD ONNX model exists in modelsDir where native code can
+ * read it. The bundled asset lives inside Electron's app.asar which native C++
+ * cannot open, so we copy it out on first run using Node.js fs (asar-aware).
+ */
+export declare function ensureSileroVadModel(modelsDir: string, logger: Logger): Promise<string>;
+export declare class SherpaSileroTurnDetectionProvider implements TurnDetectionProvider {
+    readonly id: "local";
+    private readonly config;
+    private readonly logger;
+    constructor(config: SherpaSileroVadSessionConfig, logger: Logger);
+    createSession(params: {
+        logger: Logger;
+    }): TurnDetectionSession;
+}
+//# sourceMappingURL=silero-vad-provider.d.ts.map

package/dist/server/server/speech/providers/local/sherpa/silero-vad-provider.js

@@ -0,0 +1,49 @@
+import { copyFile, mkdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { resolveBundledSileroVadModelPath, SherpaSileroVadSession, } from "./silero-vad-session.js";
+const SILERO_VAD_DIR = "silero-vad";
+const SILERO_VAD_FILE = "silero_vad.onnx";
+/**
+ * Ensure the Silero VAD ONNX model exists in modelsDir where native code can
+ * read it. The bundled asset lives inside Electron's app.asar which native C++
+ * cannot open, so we copy it out on first run using Node.js fs (asar-aware).
+ */
+export async function ensureSileroVadModel(modelsDir, logger) {
+    const destDir = path.join(modelsDir, SILERO_VAD_DIR);
+    const destPath = path.join(destDir, SILERO_VAD_FILE);
+    try {
+        const s = await stat(destPath);
+        if (s.isFile() && s.size > 0)
+            return destPath;
+    }
+    catch {
+        // not present yet
+    }
+    const bundledPath = resolveBundledSileroVadModelPath();
+    await mkdir(destDir, { recursive: true });
+    await copyFile(bundledPath, destPath);
+    logger.info({ destPath }, "Copied Silero VAD model to models directory");
+    return destPath;
+}
+export class SherpaSileroTurnDetectionProvider {
+    constructor(config, logger) {
+        this.id = "local";
+        this.config = config;
+        this.logger = logger.child({
+            module: "speech",
+            provider: "local",
+            component: "silero-vad",
+        });
+    }
+    createSession(params) {
+        this.logger.debug({ sampleRate: this.config.sampleRate, modelPath: this.config.modelPath }, "Creating Silero VAD turn-detection session");
+        return new SherpaSileroVadSession({
+            logger: params.logger.child({
+                provider: "local",
+                component: "silero-vad-session",
+            }),
+            config: this.config,
+        });
+    }
+}
+//# sourceMappingURL=silero-vad-provider.js.map

package/dist/server/server/speech/providers/local/sherpa/silero-vad-session.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter } from "node:events";
+import type { TurnDetectionSession } from "../../../turn-detection-provider.js";
+export declare function resolveBundledSileroVadModelPath(): string;
+export interface SherpaSileroVadSessionConfig {
+    modelPath?: string;
+    sampleRate?: number;
+    threshold?: number;
+    windowSize?: number;
+    bufferSizeInSeconds?: number;
+    confirmMs?: number;
+    silenceMs?: number;
+}
+export declare class SherpaSileroVadSession extends EventEmitter implements TurnDetectionSession {
+    readonly requiredSampleRate: number;
+    private readonly vad;
+    private readonly inputBuffer;
+    private readonly windowSize;
+    private readonly msPerWindow;
+    private readonly confirmMs;
+    private readonly silenceMs;
+    private connected;
+    private phase;
+    private windowTimestamp;
+    private readonly logger;
+    constructor(params: {
+        logger: {
+            debug: (...args: unknown[]) => void;
+        };
+        config?: SherpaSileroVadSessionConfig;
+    });
+    connect(): Promise<void>;
+    appendPcm16(pcm16le: Buffer): void;
+    flush(): void;
+    reset(): void;
+    close(): void;
+    private stepStateMachine;
+}
+//# sourceMappingURL=silero-vad-session.d.ts.map