@fonoster/autopilot 0.9.40 → 0.9.42

package/dist/Autopilot.js

@@ -36,11 +36,13 @@ class Autopilot {
         this.vadWorker = new worker_threads_1.Worker(vadWorkerPath, {
             workerData: conversationSettings.vad
         });
+        // Add initialization promise
         this.vadWorkerReady = new Promise((resolve, reject) => {
-            logger.verbose("waiting for vad worker to be ready");
+            console.log("waiting for vad worker to be ready");
             this.vadWorker.once("message", (message) => {
+                console.log("vad worker is ready");
                 if (message === "VAD_READY") {
-                    logger.verbose("vad worker is ready");
+                    console.log("vad worker is ready resolving promise");
                     resolve();
                 }
             });
@@ -55,7 +57,7 @@ class Autopilot {
         });
     }
     async start() {
-        // Wait for all the streams and vad worker to be ready before proceeding starting the actor
+        // Wait for VAD worker to be ready before proceeding
         await this.vadWorkerReady;
         await this.setupVoiceStream();
         await this.setupSpeechGathering();

package/dist/envs.d.ts

@@ -6,6 +6,7 @@ export declare const KNOWLEDGE_BASE_ENABLED: boolean;
 export declare const NODE_ENV: string;
 export declare const UNSTRUCTURED_API_KEY: string;
 export declare const UNSTRUCTURED_API_URL: string;
+export declare const SILERO_VAD_VERSION: string;
 export declare const CONVERSATION_PROVIDER: string;
 export declare const CONVERSATION_PROVIDER_FILE: string;
 export declare const APISERVER_ENDPOINT: string;

package/dist/envs.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SKIP_IDENTITY = exports.OPENAI_API_KEY = exports.INTEGRATIONS_FILE = exports.APISERVER_ENDPOINT = exports.CONVERSATION_PROVIDER_FILE = exports.CONVERSATION_PROVIDER = exports.UNSTRUCTURED_API_URL = exports.UNSTRUCTURED_API_KEY = exports.NODE_ENV = exports.KNOWLEDGE_BASE_ENABLED = exports.AWS_S3_SECRET_ACCESS_KEY = exports.AWS_S3_REGION = exports.AWS_S3_ENDPOINT = exports.AWS_S3_ACCESS_KEY_ID = void 0;
+exports.SKIP_IDENTITY = exports.OPENAI_API_KEY = exports.INTEGRATIONS_FILE = exports.APISERVER_ENDPOINT = exports.CONVERSATION_PROVIDER_FILE = exports.CONVERSATION_PROVIDER = exports.SILERO_VAD_VERSION = exports.UNSTRUCTURED_API_URL = exports.UNSTRUCTURED_API_KEY = exports.NODE_ENV = exports.KNOWLEDGE_BASE_ENABLED = exports.AWS_S3_SECRET_ACCESS_KEY = exports.AWS_S3_REGION = exports.AWS_S3_ENDPOINT = exports.AWS_S3_ACCESS_KEY_ID = void 0;
 /**
  * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/fonoster
@@ -39,6 +39,7 @@ exports.NODE_ENV = e.NODE_ENV || "production";
 exports.UNSTRUCTURED_API_KEY = e.AUTOPILOT_UNSTRUCTURED_API_KEY ?? "";
 exports.UNSTRUCTURED_API_URL = e.AUTOPILOT_UNSTRUCTURED_API_URL ??
     "https://api.unstructuredapp.io/general/v0/general";
+exports.SILERO_VAD_VERSION = e.AUTOPILOT_SILERO_VAD_VERSION ?? "v5";
 exports.CONVERSATION_PROVIDER = e.AUTOPILOT_CONVERSATION_PROVIDER
     ? e.AUTOPILOT_CONVERSATION_PROVIDER
     : types_1.ConversationProvider.FILE;
@@ -53,6 +54,10 @@ exports.INTEGRATIONS_FILE = e.AUTOPILOT_INTEGRATIONS_FILE
     : "/opt/fonoster/integrations.json";
 exports.OPENAI_API_KEY = e.AUTOPILOT_OPENAI_API_KEY;
 exports.SKIP_IDENTITY = e.AUTOPILOT_SKIP_IDENTITY === "true";
+if (exports.SILERO_VAD_VERSION !== "v4" && exports.SILERO_VAD_VERSION !== "v5") {
+    console.error("SILERO_VAD_VERSION must be set to 'v4' or 'v5'");
+    process.exit(1);
+}
 if (exports.CONVERSATION_PROVIDER.toLocaleLowerCase() !== types_1.ConversationProvider.API &&
     exports.CONVERSATION_PROVIDER.toLocaleLowerCase() !== types_1.ConversationProvider.FILE) {
     console.error("CONVERSATION_PROVIDER must be set to 'api' or 'file'");

package/dist/vad/SileroVad.d.ts

@@ -1,14 +1,14 @@
 import { Vad } from "./types";
 declare class SileroVad implements Vad {
     private vad;
-    private readonly params;
+    private params;
     constructor(params: {
-        pathToModel: string;
+        pathToModel?: string;
         activationThreshold: number;
         deactivationThreshold: number;
         debounceFrames: number;
     });
-    pathToModel: string;
+    pathToModel?: string;
     activationThreshold: number;
     deactivationThreshold: number;
     debounceFrames: number;

package/dist/vad/SileroVad.js

@@ -24,7 +24,7 @@ const createVad_1 = require("./createVad");
 const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
 class SileroVad {
     constructor(params) {
-        logger.verbose("starting instance of silero vad v5", { ...params });
+        logger.verbose("starting instance of silero vad v4", { ...params });
         this.params = params;
     }
     async init() {
@@ -32,7 +32,7 @@ class SileroVad {
     }
     processChunk(data, callback) {
         if (!this.vad) {
-            throw new Error("VAD not initialized");
+            throw new Error("VAD not initialized)");
         }
         this.vad(data, callback);
     }

package/dist/vad/SileroVadModel.d.ts

@@ -1,14 +1,15 @@
 import { ONNXRuntimeAPI, SpeechProbabilities } from "./types";
 declare class SileroVadModel {
-    private readonly ort;
-    private readonly pathToModel;
-    private _session;
-    private _state;
-    private _sr;
+    private ort;
+    private pathToModel;
+    _session: any;
+    _h: unknown;
+    _c: unknown;
+    _sr: unknown;
     constructor(ort: ONNXRuntimeAPI, pathToModel: string);
-    static readonly new: (ort: ONNXRuntimeAPI, pathToModel: string) => Promise<SileroVadModel>;
+    static new: (ort: ONNXRuntimeAPI, pathToModel: string) => Promise<SileroVadModel>;
     init(): Promise<void>;
-    resetState: () => void;
     process(audioFrame: Float32Array): Promise<SpeechProbabilities>;
+    resetState(): void;
 }
 export { SileroVadModel };

package/dist/vad/SileroVadModel.js

@@ -21,58 +21,40 @@ exports.SileroVadModel = void 0;
  * limitations under the License.
  */
 const fs_1 = require("fs");
-const SAMPLE_RATE = 16000;
-function getNewState(ortInstance) {
-    return new ortInstance.Tensor("float32", new Float32Array(2 * 1 * 128), // Use Float32Array for consistency
-    [2, 1, 128]);
-}
 class SileroVadModel {
     constructor(ort, pathToModel) {
         this.ort = ort;
         this.pathToModel = pathToModel;
-        this.resetState = () => {
-            this._state = getNewState(this.ort);
-        };
     }
     async init() {
         const modelArrayBuffer = (0, fs_1.readFileSync)(this.pathToModel).buffer;
-        const sessionOption = {
-            interOpNumThreads: 1,
-            intraOpNumThreads: 1,
-            enableCpuMemArena: false
-        };
-        this._session = await this.ort.InferenceSession.create(modelArrayBuffer, sessionOption);
-        // Validate model inputs/outputs
-        const requiredInputs = ["input", "state", "sr"];
-        for (const name of requiredInputs) {
-            if (!this._session.inputNames.includes(name)) {
-                throw new Error(`Model is missing expected input "${name}"`);
-            }
-        }
-        if (!this._session.outputNames.includes("output") ||
-            !this._session.outputNames.includes("stateN")) {
-            throw new Error("Model is missing expected outputs");
-        }
-        // Use BigInt for sample rate tensor
-        this._sr = new this.ort.Tensor("int64", [BigInt(SAMPLE_RATE)], []);
-        this._state = getNewState(this.ort);
+        this._session = await this.ort.InferenceSession.create(modelArrayBuffer);
+        this._sr = new this.ort.Tensor("int64", [16000n]);
+        this.resetState();
     }
     async process(audioFrame) {
-        const inputTensor = new this.ort.Tensor("float32", audioFrame, [
+        const t = new this.ort.Tensor("float32", audioFrame, [
             1,
             audioFrame.length
         ]);
-        const feeds = {
-            input: inputTensor,
-            state: this._state,
+        const inputs = {
+            input: t,
+            h: this._h,
+            c: this._c,
             sr: this._sr
         };
-        const out = await this._session.run(feeds);
-        this._state = out.stateN;
+        const out = await this._session.run(inputs);
+        this._h = out.hn;
+        this._c = out.cn;
         const [isSpeech] = out.output.data;
         const notSpeech = 1 - isSpeech;
         return { notSpeech, isSpeech };
     }
+    resetState() {
+        const zeroes = Array(2 * 64).fill(0);
+        this._h = new this.ort.Tensor("float32", zeroes, [2, 1, 64]);
+        this._c = new this.ort.Tensor("float32", zeroes, [2, 1, 64]);
+    }
 }
 exports.SileroVadModel = SileroVadModel;
 _a = SileroVadModel;

package/dist/vad/createVad.d.ts

@@ -1,3 +1,3 @@
 import { VadParams } from "./types";
 declare function createVad(params: VadParams): Promise<(chunk: Uint8Array, callback: (event: "SPEECH_START" | "SPEECH_END") => void) => Promise<void>>;
-export { createVad, VadParams };
+export { createVad };

package/dist/vad/createVad.js

@@ -58,61 +58,47 @@ const ort = __importStar(require("onnxruntime-node"));
 const chunkToFloat32Array_1 = require("./chunkToFloat32Array");
 const SileroVadModel_1 = require("./SileroVadModel");
 const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
-const FULL_FRAME_SIZE = 1024; // 64ms @ 16kHz
-const BUFFER_SIZE = 512; // 32ms @ 16kHz
+const FULL_FRAME_SIZE = 1600; // Equivalent to 100ms @ 16kHz
+const FRAME_SIZE = 480; // Use last 30ms from the full frame for VAD processing
 async function createVad(params) {
     const { pathToModel, activationThreshold, deactivationThreshold, debounceFrames } = params;
-    const effectivePath = pathToModel || (0, path_1.join)(__dirname, "..", "..", "silero_vad_v5.onnx");
-    const ortAdapter = {
-        InferenceSession: {
-            create: ort.InferenceSession.create.bind(ort.InferenceSession)
-        },
-        Tensor: ort.Tensor
-    };
-    const silero = await SileroVadModel_1.SileroVadModel.new(ortAdapter, effectivePath);
-    let sampleBuffer = [];
+    const effectivePath = pathToModel || (0, path_1.join)(__dirname, "..", "..", "silero_vad.onnx");
+    const silero = await SileroVadModel_1.SileroVadModel.new(ort, effectivePath);
+    let audioBuffer = [];
     let isSpeechActive = false;
     let framesSinceStateChange = 0;
-    // Reset internal state after a state change.
-    const resetState = () => {
-        isSpeechActive = false;
-        framesSinceStateChange = 0;
-        // Clear any pending audio samples to avoid using outdated values.
-        sampleBuffer = [];
-        silero.resetState();
-        logger.silly("State reset -- sampleBuffer cleared");
-    };
     return async function process(chunk, callback) {
-        // Convert the incoming chunk to normalized Float32 samples (using chunkToFloat32Array)
         const float32Array = (0, chunkToFloat32Array_1.chunkToFloat32Array)(chunk);
-        sampleBuffer.push(...float32Array);
-        // Wait until we've collected a full frame worth of samples.
-        while (sampleBuffer.length >= FULL_FRAME_SIZE) {
-            const fullFrame = sampleBuffer.slice(0, FULL_FRAME_SIZE);
-            sampleBuffer = sampleBuffer.slice(FULL_FRAME_SIZE);
-            // Use the last BUFFER_SIZE samples from the full frame.
-            const frame = fullFrame.slice(fullFrame.length - BUFFER_SIZE);
+        audioBuffer.push(...float32Array);
+        // Process full frames from the buffer
+        while (audioBuffer.length >= FULL_FRAME_SIZE) {
+            // Extract one full frame worth of samples
+            const fullFrame = audioBuffer.slice(0, FULL_FRAME_SIZE);
+            audioBuffer = audioBuffer.slice(FULL_FRAME_SIZE);
+            // Use the last FRAME_SIZE samples from the full frame for VAD processing
+            const frame = fullFrame.slice(fullFrame.length - FRAME_SIZE);
             const result = await silero.process(new Float32Array(frame));
             const rawScore = result.isSpeech;
             logger.silly("Frame processing", {
                 rawScore,
                 isSpeechActive,
                 framesSinceStateChange,
-                pendingSamples: sampleBuffer.length
+                pendingSamples: audioBuffer.length
             });
             framesSinceStateChange++;
             if (isSpeechActive) {
-                // If already in speech, check if the score has dropped below deactivationThreshold
+                // If currently in speech, check if the score has dropped below the deactivation threshold
                 if (rawScore < deactivationThreshold &&
                     framesSinceStateChange >= debounceFrames) {
+                    isSpeechActive = false;
                     callback("SPEECH_END");
-                    resetState();
+                    silero.resetState(); // Reset VAD state after speech ends
+                    framesSinceStateChange = 0;
                     logger.silly("Speech end detected", { rawScore });
-                    continue;
                 }
             }
             else {
-                // If currently not speaking, check if the score is above activationThreshold
+                // If not currently in speech, check if the score exceeds the activation threshold
                 if (rawScore > activationThreshold &&
                     framesSinceStateChange >= debounceFrames) {
                     isSpeechActive = true;

package/dist/vad/types.d.ts

@@ -26,35 +26,19 @@ type VadParams = {
     deactivationThreshold: number;
     debounceFrames: number;
 };
-export interface SpeechProbabilities {
+type SpeechProbabilities = {
     notSpeech: number;
     isSpeech: number;
-}
-export interface ONNXRuntimeAPI {
+};
+type ONNXRuntimeAPI = {
     InferenceSession: {
-        create: (modelPath: ArrayBuffer | string, options?: {
-            interOpNumThreads: number;
-            intraOpNumThreads: number;
-            enableCpuMemArena: boolean;
-        }) => Promise<ONNXSession>;
+        create(modelArrayBuffer: ArrayBuffer): Promise<unknown>;
+    };
+    Tensor: {
+        new (type: "int64", dims: [16000n]): unknown;
+        new (type: "float32", data: number[], dims: [2, 1, 64]): unknown;
+        new (type: "float32", data: Float32Array, dims: [1, number]): unknown;
+        new (type: "float32", data: Float32Array, dims: [1, number]): unknown;
     };
-    Tensor: new (type: string, data: Float32Array | bigint[], dims: number[]) => ONNXTensor;
-}
-export interface ONNXSession {
-    run: (feeds: {
-        [key: string]: ONNXTensor;
-    }) => Promise<{
-        output: {
-            data: Float32Array;
-        };
-        stateN: ONNXTensor;
-    }>;
-    inputNames: string[];
-    outputNames: string[];
-}
-export interface ONNXTensor {
-    data: Float32Array | bigint[];
-    dims: number[];
-    type: string;
-}
-export { Vad, VadEvent, VadParams };
+};
+export { ONNXRuntimeAPI, SpeechProbabilities, Vad, VadParams, VadEvent };

package/dist/vadWorker.js

@@ -20,11 +20,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 const path_1 = require("path");
 const worker_threads_1 = require("worker_threads");
+const envs_1 = require("./envs");
 const SileroVad_1 = require("./vad/SileroVad");
-const vad = new SileroVad_1.SileroVad({
-    ...worker_threads_1.workerData,
-    pathToModel: (0, path_1.join)(__dirname, "..", "silero_vad_v5.onnx")
-});
+const SileroVad_2 = require("./vadv5/SileroVad");
+const vad = envs_1.SILERO_VAD_VERSION === "v4"
+    ? new SileroVad_1.SileroVad({
+        ...worker_threads_1.workerData,
+        pathToModel: (0, path_1.join)(__dirname, "..", "silero_vad.onnx")
+    })
+    : new SileroVad_2.SileroVad({
+        ...worker_threads_1.workerData,
+        pathToModel: (0, path_1.join)(__dirname, "..", "silero_vad_v5.onnx")
+    });
 vad.init().then(() => {
     // Send ready message to parent
     worker_threads_1.parentPort?.postMessage("VAD_READY");

package/dist/vadv5/SileroVad.d.ts

@@ -0,0 +1,18 @@
+import { Vad } from "./types";
+declare class SileroVad implements Vad {
+    private vad;
+    private readonly params;
+    constructor(params: {
+        pathToModel: string;
+        activationThreshold: number;
+        deactivationThreshold: number;
+        debounceFrames: number;
+    });
+    pathToModel: string;
+    activationThreshold: number;
+    deactivationThreshold: number;
+    debounceFrames: number;
+    init(): Promise<void>;
+    processChunk(data: Uint8Array, callback: (event: "SPEECH_START" | "SPEECH_END") => void): void;
+}
+export { SileroVad };

package/dist/vadv5/SileroVad.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SileroVad = void 0;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const logger_1 = require("@fonoster/logger");
+const createVad_1 = require("./createVad");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+class SileroVad {
+    constructor(params) {
+        logger.verbose("starting instance of silero vad v5", { ...params });
+        this.params = params;
+    }
+    async init() {
+        this.vad = await (0, createVad_1.createVad)(this.params);
+    }
+    processChunk(data, callback) {
+        if (!this.vad) {
+            throw new Error("VAD not initialized");
+        }
+        this.vad(data, callback);
+    }
+}
+exports.SileroVad = SileroVad;

package/dist/vadv5/SileroVadModel.d.ts

@@ -0,0 +1,14 @@
+import { ONNXRuntimeAPI, SpeechProbabilities } from "./types";
+declare class SileroVadModel {
+    private readonly ort;
+    private readonly pathToModel;
+    private _session;
+    private _state;
+    private _sr;
+    constructor(ort: ONNXRuntimeAPI, pathToModel: string);
+    static readonly new: (ort: ONNXRuntimeAPI, pathToModel: string) => Promise<SileroVadModel>;
+    init(): Promise<void>;
+    resetState: () => void;
+    process(audioFrame: Float32Array): Promise<SpeechProbabilities>;
+}
+export { SileroVadModel };

package/dist/vadv5/SileroVadModel.js

@@ -0,0 +1,83 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SileroVadModel = void 0;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const fs_1 = require("fs");
+const SAMPLE_RATE = 16000;
+function getNewState(ortInstance) {
+    return new ortInstance.Tensor("float32", new Float32Array(2 * 1 * 128), // Use Float32Array for consistency
+    [2, 1, 128]);
+}
+class SileroVadModel {
+    constructor(ort, pathToModel) {
+        this.ort = ort;
+        this.pathToModel = pathToModel;
+        this.resetState = () => {
+            this._state = getNewState(this.ort);
+        };
+    }
+    async init() {
+        const modelArrayBuffer = (0, fs_1.readFileSync)(this.pathToModel).buffer;
+        const sessionOption = {
+            interOpNumThreads: 1,
+            intraOpNumThreads: 1,
+            enableCpuMemArena: false
+        };
+        this._session = await this.ort.InferenceSession.create(modelArrayBuffer, sessionOption);
+        // Validate model inputs/outputs
+        const requiredInputs = ["input", "state", "sr"];
+        for (const name of requiredInputs) {
+            if (!this._session.inputNames.includes(name)) {
+                throw new Error(`Model is missing expected input "${name}"`);
+            }
+        }
+        if (!this._session.outputNames.includes("output") ||
+            !this._session.outputNames.includes("stateN")) {
+            throw new Error("Model is missing expected outputs");
+        }
+        // Use BigInt for sample rate tensor
+        this._sr = new this.ort.Tensor("int64", [BigInt(SAMPLE_RATE)], []);
+        this._state = getNewState(this.ort);
+    }
+    async process(audioFrame) {
+        const inputTensor = new this.ort.Tensor("float32", audioFrame, [
+            1,
+            audioFrame.length
+        ]);
+        const feeds = {
+            input: inputTensor,
+            state: this._state,
+            sr: this._sr
+        };
+        const out = await this._session.run(feeds);
+        this._state = out.stateN;
+        const [isSpeech] = out.output.data;
+        const notSpeech = 1 - isSpeech;
+        return { notSpeech, isSpeech };
+    }
+}
+exports.SileroVadModel = SileroVadModel;
+_a = SileroVadModel;
+SileroVadModel.new = async (ort, pathToModel) => {
+    const model = new _a(ort, pathToModel);
+    await model.init();
+    return model;
+};

package/dist/vadv5/createVad.d.ts

@@ -0,0 +1,3 @@
+import { VadParams } from "../vad/types";
+declare function createVad(params: VadParams): Promise<(chunk: Uint8Array, callback: (event: "SPEECH_START" | "SPEECH_END") => void) => Promise<void>>;
+export { createVad, VadParams };

package/dist/vadv5/createVad.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVad = createVad;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const path_1 = require("path");
+const logger_1 = require("@fonoster/logger");
+const ort = __importStar(require("onnxruntime-node"));
+const chunkToFloat32Array_1 = require("../vad/chunkToFloat32Array");
+const SileroVadModel_1 = require("./SileroVadModel");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+const FULL_FRAME_SIZE = 1024; // 64ms @ 16kHz
+const BUFFER_SIZE = 512; // 32ms @ 16kHz
+async function createVad(params) {
+    const { pathToModel, activationThreshold, deactivationThreshold, debounceFrames } = params;
+    const effectivePath = pathToModel || (0, path_1.join)(__dirname, "..", "..", "silero_vad_v5.onnx");
+    const ortAdapter = {
+        InferenceSession: {
+            create: ort.InferenceSession.create.bind(ort.InferenceSession)
+        },
+        Tensor: ort.Tensor
+    };
+    const silero = await SileroVadModel_1.SileroVadModel.new(ortAdapter, effectivePath);
+    let sampleBuffer = [];
+    let isSpeechActive = false;
+    let framesSinceStateChange = 0;
+    // Reset internal state after a state change.
+    const resetState = () => {
+        isSpeechActive = false;
+        framesSinceStateChange = 0;
+        // Clear any pending audio samples to avoid using outdated values.
+        sampleBuffer = [];
+        silero.resetState();
+        logger.silly("State reset -- sampleBuffer cleared");
+    };
+    return async function process(chunk, callback) {
+        // Convert the incoming chunk to normalized Float32 samples (using chunkToFloat32Array)
+        const float32Array = (0, chunkToFloat32Array_1.chunkToFloat32Array)(chunk);
+        sampleBuffer.push(...float32Array);
+        // Wait until we've collected a full frame worth of samples.
+        while (sampleBuffer.length >= FULL_FRAME_SIZE) {
+            const fullFrame = sampleBuffer.slice(0, FULL_FRAME_SIZE);
+            sampleBuffer = sampleBuffer.slice(FULL_FRAME_SIZE);
+            // Use the last BUFFER_SIZE samples from the full frame.
+            const frame = fullFrame.slice(fullFrame.length - BUFFER_SIZE);
+            const result = await silero.process(new Float32Array(frame));
+            const rawScore = result.isSpeech;
+            logger.silly("Frame processing", {
+                rawScore,
+                isSpeechActive,
+                framesSinceStateChange,
+                pendingSamples: sampleBuffer.length
+            });
+            framesSinceStateChange++;
+            if (isSpeechActive) {
+                // If already in speech, check if the score has dropped below deactivationThreshold
+                if (rawScore < deactivationThreshold &&
+                    framesSinceStateChange >= debounceFrames) {
+                    callback("SPEECH_END");
+                    resetState();
+                    logger.silly("Speech end detected", { rawScore });
+                    continue;
+                }
+            }
+            else {
+                // If currently not speaking, check if the score is above activationThreshold
+                if (rawScore > activationThreshold &&
+                    framesSinceStateChange >= debounceFrames) {
+                    isSpeechActive = true;
+                    framesSinceStateChange = 0;
+                    callback("SPEECH_START");
+                    logger.silly("Speech start detected", { rawScore });
+                }
+            }
+        }
+    };
+}

package/dist/vadv5/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from "./SileroVad";
+export * from "./types";

package/dist/vadv5/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./SileroVad"), exports);
+__exportStar(require("./types"), exports);

package/dist/vadv5/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+type VadEvent = "SPEECH_START" | "SPEECH_END";
+type Vad = {
+    processChunk: (chunk: Uint8Array, callback: (event: VadEvent) => void) => void;
+};
+export interface SpeechProbabilities {
+    notSpeech: number;
+    isSpeech: number;
+}
+export interface ONNXRuntimeAPI {
+    InferenceSession: {
+        create: (modelPath: ArrayBuffer | string, options?: {
+            interOpNumThreads: number;
+            intraOpNumThreads: number;
+            enableCpuMemArena: boolean;
+        }) => Promise<ONNXSession>;
+    };
+    Tensor: new (type: string, data: Float32Array | bigint[], dims: number[]) => ONNXTensor;
+}
+export interface ONNXSession {
+    run: (feeds: {
+        [key: string]: ONNXTensor;
+    }) => Promise<{
+        output: {
+            data: Float32Array;
+        };
+        stateN: ONNXTensor;
+    }>;
+    inputNames: string[];
+    outputNames: string[];
+}
+export interface ONNXTensor {
+    data: Float32Array | bigint[];
+    dims: number[];
+    type: string;
+}
+export { Vad, VadEvent };

package/dist/vadv5/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonoster/autopilot",
-  "version": "0.9.40",
+  "version": "0.9.42",
   "description": "Voice AI for the Fonoster platform",
   "author": "Pedro Sanders <psanders@fonoster.com>",
   "homepage": "https://github.com/fonoster/fonoster#readme",
@@ -33,11 +33,11 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.712.0",
-    "@fonoster/common": "^0.9.35",
-    "@fonoster/logger": "^0.9.30",
-    "@fonoster/sdk": "^0.9.37",
-    "@fonoster/types": "^0.9.30",
-    "@fonoster/voice": "^0.9.35",
+    "@fonoster/common": "^0.9.42",
+    "@fonoster/logger": "^0.9.42",
+    "@fonoster/sdk": "^0.9.42",
+    "@fonoster/types": "^0.9.42",
+    "@fonoster/voice": "^0.9.42",
     "@langchain/community": "^0.3.32",
     "@langchain/core": "^0.3.40",
     "@langchain/groq": "^0.1.3",
@@ -56,5 +56,5 @@
     "xstate": "^5.17.3",
     "zod": "^3.23.8"
   },
-  "gitHead": "b5150ccfba8a96468d4e478796ac8e84fe57ff07"
+  "gitHead": "1ceb629d4fd0035bf56d24580e5c6c3d21568293"
 }