@fonoster/autopilot 0.8.39 → 0.8.41

package/README.md

@@ -35,7 +35,7 @@ The configuration file has two major sections: `conversationSettings` and `langu
 {
   "conversationSettings": {
     "firstMessage": "Hello, this is Olivia from Dr. Green's Family Medicine. How can I assist you today?",
-    "systemTemplate": "You are a Customer Service Representative. You are here to help the caller with their needs.",
+    "systemPrompt": "You are a Customer Service Representative. You are here to help the caller with their needs.",
     "systemErrorMessage": "I'm sorry, but I seem to be having trouble. Please try again later.",
     "initialDtmf": "6589",
     "transferOptions": {

package/dist/Autopilot.js

@@ -73,6 +73,9 @@ class Autopilot {
             if (event === "SPEECH_START") {
                 this.actor.send({ type: "SPEECH_START" });
             }
+            else if (event === "SPEECH_END") {
+                this.actor.send({ type: "SPEECH_END" });
+            }
         });
     }
     handleVoicePayload(chunk) {
@@ -89,8 +92,6 @@ class Autopilot {
         stream.onData((speech) => {
             logger.verbose("received speech result", { speech });
             if (speech) {
-                // Testing using STT for both VAD and STT (experimental)
-                this.actor.send({ type: "SPEECH_END" });
                 this.actor.send({ type: "SPEECH_RESULT", speech });
             }
         });

package/dist/envs.d.ts

@@ -7,7 +7,7 @@ export declare const KNOWLEDGE_BASE_ENABLED: boolean;
 export declare const NODE_ENV: string;
 export declare const UNSTRUCTURED_API_KEY: string | undefined;
 export declare const UNSTRUCTURED_API_URL: string;
-export declare const SILERO_VAD_MODEL_PATH: 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.INTEGRATIONS_FILE = exports.APISERVER_ENDPOINT = exports.CONVERSATION_PROVIDER_FILE = exports.CONVERSATION_PROVIDER = exports.SILERO_VAD_MODEL_PATH = 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 = exports.SKIP_IDENTITY = void 0;
+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 = exports.SKIP_IDENTITY = void 0;
 /*
  * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/fonoster
@@ -39,7 +39,7 @@ exports.KNOWLEDGE_BASE_ENABLED = e.KNOWLEDGE_BASE_ENABLED === "true";
 exports.NODE_ENV = e.NODE_ENV || "production";
 exports.UNSTRUCTURED_API_KEY = e.UNSTRUCTURED_API_KEY;
 exports.UNSTRUCTURED_API_URL = e.UNSTRUCTURED_API_URL ?? "https://api.unstructuredapp.io/general/v0/general";
-exports.SILERO_VAD_MODEL_PATH = e.SILERO_VAD_MODEL_PATH ?? (0, path_1.join)(__dirname, "..", "silero_vad.onnx");
+exports.SILERO_VAD_VERSION = e.SILERO_VAD_VERSION ?? "v4";
 exports.CONVERSATION_PROVIDER = e.CONVERSATION_PROVIDER
     ? e.CONVERSATION_PROVIDER
     : types_1.ConversationProvider.FILE;
@@ -52,6 +52,10 @@ exports.APISERVER_ENDPOINT = e.APISERVER_ENDPOINT
 exports.INTEGRATIONS_FILE = e.INTEGRATIONS_FILE
     ? e.INTEGRATIONS_FILE
     : `${process.cwd()}/config/integrations.json`;
+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/machine/machine.d.ts

@@ -9,8 +9,6 @@ declare const machine: import("xstate").StateMachine<AutopilotContext, {
 } | {
     type: "SPEECH_RESULT";
     speech: string;
-} | {
-    type: "USER_REQUEST_PROCESSED";
 }, {
     [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, {
         context: AutopilotContext;
@@ -66,20 +64,11 @@ declare const machine: import("xstate").StateMachine<AutopilotContext, {
         type: "setSpeakingDone";
         params: import("xstate").NonReducibleUnknown;
     };
-}>, import("xstate").Values<{
-    idleTimeoutCountExceedsMax: {
-        type: "idleTimeoutCountExceedsMax";
-        params: unknown;
-    };
-    hasSpeechResult: {
-        type: "hasSpeechResult";
-        params: unknown;
-    };
-    isNotSpeaking: {
-        type: "isNotSpeaking";
-        params: unknown;
+    resetState: {
+        type: "resetState";
+        params: import("xstate").NonReducibleUnknown;
     };
-}>, "IDLE_TIMEOUT" | "MAX_SPEECH_WAIT_TIMEOUT", {}, string, {
+}>, never, "IDLE_TIMEOUT" | "MAX_SPEECH_WAIT_TIMEOUT" | "SESSION_TIMEOUT", {}, string, {
     conversationSettings: ConversationSettings;
     languageModel: LanguageModel;
     voice: Voice;
@@ -90,8 +79,6 @@ declare const machine: import("xstate").StateMachine<AutopilotContext, {
 } | {
     type: "SPEECH_RESULT";
     speech: string;
-} | {
-    type: "USER_REQUEST_PROCESSED";
 }, {
     src: "doProcessUserRequest";
     logic: import("xstate").PromiseActorLogic<void, {
@@ -143,20 +130,11 @@ declare const machine: import("xstate").StateMachine<AutopilotContext, {
         type: "setSpeakingDone";
         params: import("xstate").NonReducibleUnknown;
     };
-}>, import("xstate").Values<{
-    idleTimeoutCountExceedsMax: {
-        type: "idleTimeoutCountExceedsMax";
-        params: unknown;
-    };
-    hasSpeechResult: {
-        type: "hasSpeechResult";
-        params: unknown;
-    };
-    isNotSpeaking: {
-        type: "isNotSpeaking";
-        params: unknown;
+    resetState: {
+        type: "resetState";
+        params: import("xstate").NonReducibleUnknown;
     };
-}>, "IDLE_TIMEOUT" | "MAX_SPEECH_WAIT_TIMEOUT", string, {
+}>, never, "IDLE_TIMEOUT" | "MAX_SPEECH_WAIT_TIMEOUT" | "SESSION_TIMEOUT", string, {
     conversationSettings: ConversationSettings;
     languageModel: LanguageModel;
     voice: Voice;

package/dist/machine/machine.js

@@ -78,7 +78,10 @@ const machine = (0, xstate_1.setup)({
                 speech: event.speech
             });
             const speech = event.speech;
-            context.speechBuffer = ((context.speechBuffer || "") +
+            if (!speech) {
+                return context;
+            }
+            context.speechBuffer = ((context.speechBuffer ?? "") +
                 " " +
                 speech).trimStart();
             return context;
@@ -103,24 +106,33 @@ const machine = (0, xstate_1.setup)({
             });
             context.isSpeaking = false;
             return context;
+        }),
+        resetState: (0, xstate_1.assign)(({ context }) => {
+            logger.verbose("called resetState action");
+            return {
+                ...context,
+                speechBuffer: "",
+                idleTimeoutCount: 0,
+                isSpeaking: false
+            };
         })
     },
     guards: {
         idleTimeoutCountExceedsMax: function ({ context }) {
             logger.verbose("called idleTimeoutCountExceedsMax guard", {
-                idleTimeoutCount: context.idleTimeoutCount,
+                idleTimeoutCount: context.idleTimeoutCount + 1,
                 maxIdleTimeoutCount: context.maxIdleTimeoutCount
             });
-            return context.idleTimeoutCount >= context.maxIdleTimeoutCount;
+            return context.idleTimeoutCount + 1 > context.maxIdleTimeoutCount;
         },
         hasSpeechResult: function ({ context }) {
-            return context.speechBuffer !== "";
+            return context.speechBuffer;
         },
-        isNotSpeaking: function ({ context }) {
-            logger.verbose("called isNotSpeaking guard", {
+        isSpeaking: function ({ context }) {
+            logger.verbose("called isSpeaking guard", {
                 isSpeaking: context.isSpeaking
             });
-            return !context.isSpeaking;
+            return context.isSpeaking;
         }
     },
     delays: {
@@ -129,6 +141,10 @@ const machine = (0, xstate_1.setup)({
         },
         MAX_SPEECH_WAIT_TIMEOUT: ({ context }) => {
             return context.maxSpeechWaitTimeout;
+        },
+        SESSION_TIMEOUT: ({ context }) => {
+            const elapsed = Date.now() - context.sessionStartTime;
+            return Math.max(0, context.maxSessionDuration - elapsed);
         }
     },
     actors: {
@@ -175,6 +191,18 @@ const machine = (0, xstate_1.setup)({
                 await context.voice.say(context.systemErrorMessage);
             }
         })
+    },
+    on: {
+        ERROR: {
+            target: "systemError",
+            actions: "logError"
+        }
+    },
+    after: {
+        SESSION_TIMEOUT: {
+            target: "hangup",
+            actions: ["goodbye"]
+        }
     }
 }).createMachine({
     context: ({ input }) => ({
@@ -192,8 +220,9 @@ const machine = (0, xstate_1.setup)({
         maxIdleTimeoutCount: input.conversationSettings.idleOptions?.maxTimeoutCount || 3,
         idleTimeoutCount: 0,
         maxSpeechWaitTimeout: input.conversationSettings.maxSpeechWaitTimeout,
-        speechResponseTime: 0,
-        isSpeaking: false
+        isSpeaking: false,
+        sessionStartTime: Date.now(),
+        maxSessionDuration: input.conversationSettings.maxSessionDuration
     }),
     id: "fnAI",
     initial: "greeting",
@@ -207,110 +236,103 @@ const machine = (0, xstate_1.setup)({
             }
         },
         idle: {
+            entry: { type: "cleanSpeech" },
             on: {
                 SPEECH_START: {
                     target: "waitingForUserRequest",
                     description: "Event from VAD system."
-                },
-                SPEECH_RESULT: {
-                    target: "waitingForUserRequest",
-                    description: "Event from Speech to Text provider."
                 }
             },
             after: {
                 IDLE_TIMEOUT: [
                     {
                         target: "hangup",
-                        actions: {
-                            type: "goodbye"
-                        },
-                        guard: {
-                            type: "idleTimeoutCountExceedsMax"
-                        }
+                        actions: { type: "goodbye" },
+                        guard: (0, xstate_1.and)(["idleTimeoutCountExceedsMax", (0, xstate_1.not)("isSpeaking")])
                     },
                     {
-                        target: "transitioningToIdle",
+                        target: "idleTransition",
+                        guard: (0, xstate_1.not)("isSpeaking"),
                         actions: [
-                            {
-                                type: "increaseIdleTimeoutCount"
-                            },
-                            {
-                                type: "announceIdleTimeout"
-                            }
+                            { type: "increaseIdleTimeoutCount" },
+                            { type: "announceIdleTimeout" }
                         ]
                     }
                 ]
             }
         },
+        idleTransition: {
+            always: {
+                target: "idle"
+            }
+        },
         waitingForUserRequest: {
             always: {
                 target: "updatingSpeech"
             },
             entry: [
-                {
-                    type: "cleanSpeech"
-                },
-                {
-                    type: "interruptPlayback"
-                },
-                {
-                    type: "resetIdleTimeoutCount"
-                },
-                {
-                    type: "setSpeaking"
-                }
+                { type: "interruptPlayback" },
+                { type: "resetIdleTimeoutCount" },
+                { type: "setSpeaking" }
             ]
         },
         hangup: {
             type: "final"
         },
-        transitioningToIdle: {
-            always: {
-                target: "idle"
-            }
-        },
         updatingSpeech: {
             on: {
-                SPEECH_RESULT: [
+                SPEECH_END: [
                     {
                         target: "processingUserRequest",
-                        actions: {
-                            type: "appendSpeech"
-                        },
-                        guard: {
-                            type: "isNotSpeaking"
-                        },
-                        description: "Speech result from the Speech to Text provider."
+                        guard: "hasSpeechResult",
+                        actions: [{ type: "setSpeakingDone" }],
+                        description: "Process immediately if we have speech"
                     },
                     {
-                        target: "updatingSpeech",
-                        actions: {
-                            type: "appendSpeech"
-                        }
+                        target: "waitingForSpeechTimeout",
+                        guard: (0, xstate_1.not)("hasSpeechResult"),
+                        actions: [{ type: "setSpeakingDone" }],
+                        description: "Wait for more speech if no results yet"
                     }
                 ],
-                SPEECH_END: [
+                SPEECH_RESULT: [
+                    {
+                        actions: { type: "appendSpeech" },
+                        guard: "isSpeaking",
+                        description: "Just append the speech result."
+                    },
                     {
                         target: "processingUserRequest",
-                        actions: {
-                            type: "setSpeakingDone"
-                        },
-                        guard: {
-                            type: "hasSpeechResult"
-                        },
-                        description: "Event from VAD or similar system."
+                        actions: { type: "appendSpeech" },
+                        guard: (0, xstate_1.not)("isSpeaking"),
+                        description: "Append the speech result and process it."
+                    }
+                ]
+            }
+        },
+        waitingForSpeechTimeout: {
+            after: {
+                MAX_SPEECH_WAIT_TIMEOUT: [
+                    {
+                        target: "processingUserRequest",
+                        guard: "hasSpeechResult"
                     },
                     {
-                        target: "updatingSpeech",
-                        actions: {
-                            type: "setSpeakingDone"
-                        }
+                        target: "idle"
                     }
                 ]
             },
-            after: {
-                MAX_SPEECH_WAIT_TIMEOUT: {
-                    target: "processingUserRequest"
+            on: {
+                SPEECH_START: {
+                    target: "waitingForUserRequest",
+                    description: "User started speaking again"
+                },
+                SPEECH_RESULT: {
+                    target: "processingUserRequest",
+                    actions: {
+                        type: "appendSpeech"
+                    },
+                    description: "Append final speech and process the request"
                 }
             }
         },
@@ -318,7 +340,17 @@ const machine = (0, xstate_1.setup)({
             on: {
                 SPEECH_START: {
                     target: "waitingForUserRequest",
-                    description: "Event from VAD or similar system."
+                    description: "Event from VAD or similar system.",
+                    actions: [{ type: "interruptPlayback" }, { type: "cleanSpeech" }]
+                },
+                SPEECH_RESULT: {
+                    target: "waitingForUserRequest",
+                    description: "User interrupted with new speech",
+                    actions: [
+                        { type: "interruptPlayback" },
+                        { type: "cleanSpeech" },
+                        { type: "appendSpeech" }
+                    ]
                 }
             },
             invoke: {
@@ -328,6 +360,15 @@ const machine = (0, xstate_1.setup)({
                     target: "idle"
                 }
             }
+        },
+        systemError: {
+            entry: "announceSystemError",
+            after: {
+                SYSTEM_ERROR_RECOVERY_TIMEOUT: {
+                    target: "idle",
+                    actions: "resetState"
+                }
+            }
         }
     }
 });

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

@@ -21,15 +21,15 @@ exports.SileroVad = void 0;
  * limitations under the License.
  */
 const logger_1 = require("@fonoster/logger");
-const createVad_1 = require("./createVad");
+const makeVad_1 = require("./makeVad");
 const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
 class SileroVad {
     constructor(params) {
-        logger.verbose("starting instance of silero vad", { ...params });
+        logger.verbose("starting instance of silero vad v4", { ...params });
         this.params = params;
     }
     async init() {
-        this.vad = await (0, createVad_1.createVad)(this.params);
+        this.vad = await (0, makeVad_1.makeVad)(this.params);
     }
     processChunk(data, callback) {
         if (!this.vad) {

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,24 +21,16 @@ exports.SileroVadModel = void 0;
  * limitations under the License.
  */
 const fs_1 = require("fs");
-function getNewState(ortInstance) {
-    const zeroes = Array(2 * 128).fill(0);
-    return new ortInstance.Tensor("float32", zeroes, [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 };
-        this._session = await this.ort.InferenceSession.create(modelArrayBuffer, sessionOption);
+        this._session = await this.ort.InferenceSession.create(modelArrayBuffer);
         this._sr = new this.ort.Tensor("int64", [16000n]);
-        this._state = getNewState(this.ort);
+        this.resetState();
     }
     async process(audioFrame) {
         const t = new this.ort.Tensor("float32", audioFrame, [
@@ -47,15 +39,22 @@ class SileroVadModel {
         ]);
         const inputs = {
             input: t,
-            state: this._state,
+            h: this._h,
+            c: this._c,
             sr: this._sr
         };
         const out = await this._session.run(inputs);
-        this._state = out["stateN"];
-        const [isSpeech] = out["output"].data;
+        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/chunkToFloat32Array.js

@@ -24,12 +24,14 @@ exports.chunkToFloat32Array = chunkToFloat32Array;
 //
 // Q. Would it be the same if we just created a new Uint8Array from the chunk?
 function chunkToFloat32Array(chunk) {
-    let int16Array;
+    // Check if byteOffset is not aligned
     const alignedByteOffset = chunk.byteOffset % Int16Array.BYTES_PER_ELEMENT === 0;
+    let int16Array;
     if (alignedByteOffset) {
         int16Array = new Int16Array(chunk.buffer, chunk.byteOffset, chunk.byteLength / Int16Array.BYTES_PER_ELEMENT);
     }
     else {
+        // Create a new aligned Uint8Array and then an Int16Array from it
         const alignedChunk = new Uint8Array(chunk);
         int16Array = new Int16Array(alignedChunk.buffer, alignedChunk.byteOffset, alignedChunk.byteLength / Int16Array.BYTES_PER_ELEMENT);
     }

package/dist/vad/makeVad.d.ts

@@ -0,0 +1,7 @@
+declare function makeVad(params: {
+    pathToModel?: string;
+    activationThreshold: number;
+    deactivationThreshold: number;
+    debounceFrames: number;
+}): Promise<(chunk: Uint8Array, callback: (event: "SPEECH_START" | "SPEECH_END") => void) => Promise<void>>;
+export { makeVad };

package/dist/vad/makeVad.js

@@ -0,0 +1,104 @@
+"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.makeVad = makeVad;
+/* eslint-disable no-loops/no-loops */
+/*
+ * 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("./chunkToFloat32Array");
+const SileroVadModel_1 = require("./SileroVadModel");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+const BUFFER_SIZE = 16000;
+async function makeVad(params) {
+    const { pathToModel, activationThreshold, deactivationThreshold, debounceFrames } = params;
+    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 consecutiveSpeechFrames = 0;
+    let consecutiveNonSpeechFrames = 0;
+    return async function process(chunk, callback) {
+        const float32Array = (0, chunkToFloat32Array_1.chunkToFloat32Array)(chunk);
+        audioBuffer.push(...float32Array);
+        const processBuffer = async (buffer) => {
+            if (buffer.length < BUFFER_SIZE)
+                return buffer;
+            const audioFrame = buffer.slice(0, BUFFER_SIZE);
+            const remainingBuffer = buffer.slice(BUFFER_SIZE);
+            const result = await silero.process(new Float32Array(audioFrame));
+            logger.silly("last vad result", { ...result });
+            if (result.isSpeech > activationThreshold) {
+                consecutiveNonSpeechFrames = 0; // Reset non-speech counter
+                consecutiveSpeechFrames++;
+                if (consecutiveSpeechFrames >= debounceFrames && !isSpeechActive) {
+                    isSpeechActive = true;
+                    callback("SPEECH_START");
+                }
+            }
+            else {
+                consecutiveSpeechFrames = 0; // Reset speech counter
+                consecutiveNonSpeechFrames++;
+                if (consecutiveNonSpeechFrames >= debounceFrames &&
+                    isSpeechActive &&
+                    result.isSpeech < deactivationThreshold) {
+                    isSpeechActive = false;
+                    callback("SPEECH_END");
+                    silero.resetState(); // Reset VAD state after speech ends
+                }
+            }
+            return processBuffer(remainingBuffer);
+        };
+        audioBuffer = await processBuffer(audioBuffer);
+    };
+}

package/dist/vad/types.d.ts

@@ -8,15 +8,12 @@ type SpeechProbabilities = {
 };
 type ONNXRuntimeAPI = {
     InferenceSession: {
-        create(modelArrayBuffer: ArrayBuffer, sessionOption: {
-            interOpNumThreads: number;
-            intraOpNumThreads: number;
-        }): Promise<unknown>;
+        create(modelArrayBuffer: ArrayBuffer): Promise<unknown>;
     };
     Tensor: {
-        new (type: "int64", data: BigInt[]): unknown;
-        new (type: "int64", data: BigInt[], dims: [1]): unknown;
-        new (type: "float32", data: Float32Array | number[], dims: [2, 1, 128]): unknown;
+        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;
     };
 };

package/dist/vadWorker.js

@@ -20,10 +20,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 const worker_threads_1 = require("worker_threads");
 const SileroVad_1 = require("./vad/SileroVad");
+const SileroVad_2 = require("./vadv5/SileroVad");
 const envs_1 = require("./envs");
-const vad = new SileroVad_1.SileroVad({
+const path_1 = require("path");
+const vad = envs_1.SILERO_VAD_VERSION === "v4" ? new SileroVad_1.SileroVad({
     ...worker_threads_1.workerData,
-    pathToModel: envs_1.SILERO_VAD_MODEL_PATH
+    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(() => {
     worker_threads_1.parentPort?.on("message", (chunk) => {

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,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SileroVad = void 0;
+/* eslint-disable no-loops/no-loops */
+/*
+ * 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,66 @@
+"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");
+function getNewState(ortInstance) {
+    const zeroes = Array(2 * 128).fill(0);
+    return new ortInstance.Tensor("float32", zeroes, [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 };
+        this._session = await this.ort.InferenceSession.create(modelArrayBuffer, sessionOption);
+        this._sr = new this.ort.Tensor("int64", [16000n]);
+        this._state = getNewState(this.ort);
+    }
+    async process(audioFrame) {
+        const t = new this.ort.Tensor("float32", audioFrame, [
+            1,
+            audioFrame.length
+        ]);
+        const inputs = {
+            input: t,
+            state: this._state,
+            sr: this._sr
+        };
+        const out = await this._session.run(inputs);
+        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/chunkToFloat32Array.d.ts

@@ -0,0 +1,2 @@
+declare function chunkToFloat32Array(chunk: Uint8Array): Float32Array;
+export { chunkToFloat32Array };

package/dist/vadv5/chunkToFloat32Array.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkToFloat32Array = chunkToFloat32Array;
+// This version of the chunkToFloat32Array accounts for the case where
+// the byteOffset is misaligned.
+//
+// Q. Would it be the same if we just created a new Uint8Array from the chunk?
+function chunkToFloat32Array(chunk) {
+    let int16Array;
+    const alignedByteOffset = chunk.byteOffset % Int16Array.BYTES_PER_ELEMENT === 0;
+    if (alignedByteOffset) {
+        int16Array = new Int16Array(chunk.buffer, chunk.byteOffset, chunk.byteLength / Int16Array.BYTES_PER_ELEMENT);
+    }
+    else {
+        const alignedChunk = new Uint8Array(chunk);
+        int16Array = new Int16Array(alignedChunk.buffer, alignedChunk.byteOffset, alignedChunk.byteLength / Int16Array.BYTES_PER_ELEMENT);
+    }
+    const floatArray = new Float32Array(int16Array.length);
+    for (let i = 0; i < int16Array.length; i++) {
+        floatArray[i] = int16Array[i] / 32768.0;
+    }
+    return floatArray;
+}

package/dist/vadv5/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./SileroVad";
+export * from "./types";

package/dist/vadv5/index.js

@@ -0,0 +1,37 @@
+"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 });
+/* eslint-disable no-loops/no-loops */
+/*
+ * 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,23 @@
+type VadEvent = "SPEECH_START" | "SPEECH_END";
+type Vad = {
+    processChunk: (chunk: Uint8Array, callback: (event: VadEvent) => void) => void;
+};
+type SpeechProbabilities = {
+    notSpeech: number;
+    isSpeech: number;
+};
+type ONNXRuntimeAPI = {
+    InferenceSession: {
+        create(modelArrayBuffer: ArrayBuffer, sessionOption: {
+            interOpNumThreads: number;
+            intraOpNumThreads: number;
+        }): Promise<unknown>;
+    };
+    Tensor: {
+        new (type: "int64", data: BigInt[]): unknown;
+        new (type: "int64", data: BigInt[], dims: [1]): unknown;
+        new (type: "float32", data: Float32Array | number[], dims: [2, 1, 128]): unknown;
+        new (type: "float32", data: Float32Array, dims: [1, number]): unknown;
+    };
+};
+export { ONNXRuntimeAPI, SpeechProbabilities, 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.8.39",
+  "version": "0.8.41",
   "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.8.39",
-    "@fonoster/logger": "^0.8.39",
-    "@fonoster/sdk": "^0.8.39",
-    "@fonoster/types": "^0.8.39",
-    "@fonoster/voice": "^0.8.39",
+    "@fonoster/common": "^0.8.41",
+    "@fonoster/logger": "^0.8.41",
+    "@fonoster/sdk": "^0.8.41",
+    "@fonoster/types": "^0.8.41",
+    "@fonoster/voice": "^0.8.41",
     "@langchain/community": "^0.3.19",
     "@langchain/core": "^0.3.23",
     "@langchain/groq": "^0.1.2",
@@ -55,5 +55,5 @@
   "devDependencies": {
     "typescript": "^5.5.4"
   },
-  "gitHead": "3ba2a5330d268f5be03fd9d5bbd22aeeb264fa61"
+  "gitHead": "9aeac381dc6e2864d81b3fcc8dfe6f067910516f"
 }