@vapi-ai/web 1.1.6 → 1.1.7

package/dist/AtomicMediaSource.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import EventEmitter from "events";
+declare global {
+    interface Window {
+        ManagedMediaSource: any;
+    }
+}
+declare class AtomicMediaSource extends EventEmitter {
+    mediaSource: any;
+    sourceBuffer: SourceBuffer | null;
+    private operationsQueue;
+    constructor();
+    appendBuffer(buffer: ArrayBuffer): void;
+    clearBuffer(): void;
+    private createOperationQueue;
+}
+export default AtomicMediaSource;

package/dist/AtomicMediaSource.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const async_1 = __importDefault(require("async"));
+const events_1 = __importDefault(require("events"));
+// ManagedMediaSource needed for iOS Safari
+function getMediaSource() {
+    if (window.ManagedMediaSource) {
+        return new window.ManagedMediaSource();
+    }
+    if (window.MediaSource) {
+        return new window.MediaSource();
+    }
+    return null;
+}
+class AtomicMediaSource extends events_1.default {
+    constructor() {
+        super();
+        this.sourceBuffer = null;
+        this.mediaSource = getMediaSource();
+        this.operationsQueue = this.createOperationQueue();
+        if (!this.mediaSource) {
+            console.error("MediaSource is not supported in your browser.");
+            // Display a message to the user, or handle this situation in another way
+            return;
+        }
+        this.mediaSource.addEventListener("sourceopen", () => {
+            this.mediaSource.duration = Number.POSITIVE_INFINITY;
+            this.sourceBuffer = this.mediaSource.addSourceBuffer('audio/webm; codecs="opus"');
+            if (this.sourceBuffer) {
+                this.sourceBuffer.mode = "sequence";
+            }
+        });
+    }
+    appendBuffer(buffer) {
+        this.operationsQueue.push(() => {
+            return new Promise((resolve, reject) => {
+                if (this.sourceBuffer) {
+                    this.sourceBuffer.addEventListener("updateend", () => {
+                        resolve();
+                    }, { once: true });
+                    this.sourceBuffer.appendBuffer(buffer);
+                }
+                else {
+                    reject();
+                }
+            });
+        });
+    }
+    clearBuffer() {
+        // this.operationsQueue.push(() => {
+        //   return new Promise((resolve, reject) => {
+        //     if (this.sourceBuffer) {
+        //       this.sourceBuffer.addEventListener(
+        //         "updateend",
+        //         () => {
+        //           resolve();
+        //         },
+        //         { once: true }
+        //       );
+        //       if (this.sourceBuffer.buffered.length > 0) {
+        //         this.sourceBuffer.remove(0, this.sourceBuffer.buffered.end(0));
+        //       }
+        //     } else {
+        //       reject();
+        //     }
+        //   });
+        // });
+    }
+    createOperationQueue() {
+        return async_1.default.queue((task, callback) => {
+            task().then(() => callback());
+        }, 1);
+    }
+}
+exports.default = AtomicMediaSource;

package/dist/player.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import EventEmitter from "events";
+export declare class ContinuousPlayer extends EventEmitter {
+    private atomic;
+    private audio;
+    constructor();
+    start(): void;
+    playChunk(audioData: ArrayBuffer): void;
+    clear(): void;
+}

package/dist/player.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContinuousPlayer = void 0;
+const AtomicMediaSource_1 = __importDefault(require("./AtomicMediaSource"));
+const events_1 = __importDefault(require("events"));
+class ContinuousPlayer extends events_1.default {
+    constructor() {
+        super();
+        this.audio = document.createElement("audio");
+        this.audio.addEventListener("playing", () => this.emit("speech-start"));
+        this.audio.addEventListener("play", () => this.emit("speech-start"));
+        this.audio.addEventListener("canplay", () => {
+            this.audio.play();
+        });
+        this.audio.addEventListener("waiting", () => this.emit("speech-end"));
+        this.atomic = new AtomicMediaSource_1.default();
+        this.audio.src = URL.createObjectURL(this.atomic.mediaSource);
+        document.body.appendChild(this.audio);
+    }
+    start() {
+        this.audio.play();
+    }
+    playChunk(audioData) {
+        var _a;
+        (_a = this.atomic.sourceBuffer) === null || _a === void 0 ? void 0 : _a.addEventListener("updateend", () => {
+            this.audio.play().catch((error) => console.error("Play error:", error));
+        }, { once: true });
+        this.atomic.appendBuffer(audioData);
+    }
+    clear() {
+        this.audio.pause();
+        this.atomic.clearBuffer();
+    }
+}
+exports.ContinuousPlayer = ContinuousPlayer;

package/dist/vapi.d.ts

@@ -10,7 +10,12 @@ export interface ControlMessages {
     type: 'control';
     control: 'mute-assistant' | 'unmute-assistant';
 }
-type VapiClientToServerMessage = AddMessageMessage | ControlMessages;
+export interface SayMessage {
+    type: 'say';
+    message: string;
+    endCallAfterSpoken?: boolean;
+}
+type VapiClientToServerMessage = AddMessageMessage | ControlMessages | SayMessage;
 type VapiEventNames = 'call-end' | 'call-start' | 'volume-level' | 'speech-start' | 'speech-end' | 'message' | 'error';
 type VapiEventListeners = {
     'call-end': () => void;
@@ -42,5 +47,6 @@ export default class Vapi extends VapiEventEmitter {
     send(message: VapiClientToServerMessage): void;
     setMuted(mute: boolean): void;
     isMuted(): boolean;
+    say(message: string, endCallAfterSpoken?: boolean): void;
 }
 export {};

package/dist/vapi.js

@@ -218,5 +218,12 @@ class Vapi extends VapiEventEmitter {
             throw error;
         }
     }
+    say(message, endCallAfterSpoken) {
+        this.send({
+            type: 'say',
+            message,
+            endCallAfterSpoken
+        });
+    }
 }
 exports.default = Vapi;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vapi-ai/web",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "",
   "main": "dist/vapi.js",
   "types": "dist/vapi.d.ts",

package/vapi.ts

@@ -50,7 +50,13 @@ export interface ControlMessages {
   control: 'mute-assistant' | 'unmute-assistant';
 }
 
-type VapiClientToServerMessage = AddMessageMessage | ControlMessages;
+export interface SayMessage {
+  type: 'say';
+  message: string;
+  endCallAfterSpoken?: boolean;
+}
+
+type VapiClientToServerMessage = AddMessageMessage | ControlMessages | SayMessage;
 
 type VapiEventNames =
   | 'call-end'
@@ -275,4 +281,12 @@ export default class Vapi extends VapiEventEmitter {
       throw error;
     }
   }
+
+  public say(message: string, endCallAfterSpoken?: boolean) {
+    this.send({
+      type:'say', 
+      message,
+      endCallAfterSpoken
+    })
+  }
 }