@vapi-ai/web 1.0.0

package/dist/api.js

@@ -0,0 +1,309 @@
+"use strict";
+/* eslint-disable */
+/* tslint:disable */
+/*
+ * ---------------------------------------------------------------
+ * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
+ * ##                                                           ##
+ * ## AUTHOR: acacode                                           ##
+ * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
+ * ---------------------------------------------------------------
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = exports.HttpClient = exports.ContentType = void 0;
+var ContentType;
+(function (ContentType) {
+    ContentType["Json"] = "application/json";
+    ContentType["FormData"] = "multipart/form-data";
+    ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
+    ContentType["Text"] = "text/plain";
+})(ContentType || (exports.ContentType = ContentType = {}));
+class HttpClient {
+    constructor(apiConfig = {}) {
+        this.baseUrl = "";
+        this.securityData = null;
+        this.abortControllers = new Map();
+        this.customFetch = (...fetchParams) => fetch(...fetchParams);
+        this.baseApiParams = {
+            credentials: "same-origin",
+            headers: {},
+            redirect: "follow",
+            referrerPolicy: "no-referrer",
+        };
+        this.setSecurityData = (data) => {
+            this.securityData = data;
+        };
+        this.contentFormatters = {
+            [ContentType.Json]: (input) => input !== null && (typeof input === "object" || typeof input === "string") ? JSON.stringify(input) : input,
+            [ContentType.Text]: (input) => (input !== null && typeof input !== "string" ? JSON.stringify(input) : input),
+            [ContentType.FormData]: (input) => Object.keys(input || {}).reduce((formData, key) => {
+                const property = input[key];
+                formData.append(key, property instanceof Blob
+                    ? property
+                    : typeof property === "object" && property !== null
+                        ? JSON.stringify(property)
+                        : `${property}`);
+                return formData;
+            }, new FormData()),
+            [ContentType.UrlEncoded]: (input) => this.toQueryString(input),
+        };
+        this.createAbortSignal = (cancelToken) => {
+            if (this.abortControllers.has(cancelToken)) {
+                const abortController = this.abortControllers.get(cancelToken);
+                if (abortController) {
+                    return abortController.signal;
+                }
+                return void 0;
+            }
+            const abortController = new AbortController();
+            this.abortControllers.set(cancelToken, abortController);
+            return abortController.signal;
+        };
+        this.abortRequest = (cancelToken) => {
+            const abortController = this.abortControllers.get(cancelToken);
+            if (abortController) {
+                abortController.abort();
+                this.abortControllers.delete(cancelToken);
+            }
+        };
+        this.request = (_a) => __awaiter(this, void 0, void 0, function* () {
+            var { body, secure, path, type, query, format, baseUrl, cancelToken } = _a, params = __rest(_a, ["body", "secure", "path", "type", "query", "format", "baseUrl", "cancelToken"]);
+            const secureParams = ((typeof secure === "boolean" ? secure : this.baseApiParams.secure) &&
+                this.securityWorker &&
+                (yield this.securityWorker(this.securityData))) ||
+                {};
+            const requestParams = this.mergeRequestParams(params, secureParams);
+            const queryString = query && this.toQueryString(query);
+            const payloadFormatter = this.contentFormatters[type || ContentType.Json];
+            const responseFormat = format || requestParams.format;
+            return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, Object.assign(Object.assign({}, requestParams), { headers: Object.assign(Object.assign({}, (requestParams.headers || {})), (type && type !== ContentType.FormData ? { "Content-Type": type } : {})), signal: (cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal) || null, body: typeof body === "undefined" || body === null ? null : payloadFormatter(body) })).then((response) => __awaiter(this, void 0, void 0, function* () {
+                const r = response;
+                r.data = null;
+                r.error = null;
+                const data = !responseFormat
+                    ? r
+                    : yield response[responseFormat]()
+                        .then((data) => {
+                        if (r.ok) {
+                            r.data = data;
+                        }
+                        else {
+                            r.error = data;
+                        }
+                        return r;
+                    })
+                        .catch((e) => {
+                        r.error = e;
+                        return r;
+                    });
+                if (cancelToken) {
+                    this.abortControllers.delete(cancelToken);
+                }
+                if (!response.ok)
+                    throw data;
+                return data;
+            }));
+        });
+        Object.assign(this, apiConfig);
+    }
+    encodeQueryParam(key, value) {
+        const encodedKey = encodeURIComponent(key);
+        return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : `${value}`)}`;
+    }
+    addQueryParam(query, key) {
+        return this.encodeQueryParam(key, query[key]);
+    }
+    addArrayQueryParam(query, key) {
+        const value = query[key];
+        return value.map((v) => this.encodeQueryParam(key, v)).join("&");
+    }
+    toQueryString(rawQuery) {
+        const query = rawQuery || {};
+        const keys = Object.keys(query).filter((key) => "undefined" !== typeof query[key]);
+        return keys
+            .map((key) => (Array.isArray(query[key]) ? this.addArrayQueryParam(query, key) : this.addQueryParam(query, key)))
+            .join("&");
+    }
+    addQueryParams(rawQuery) {
+        const queryString = this.toQueryString(rawQuery);
+        return queryString ? `?${queryString}` : "";
+    }
+    mergeRequestParams(params1, params2) {
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, this.baseApiParams), params1), (params2 || {})), { headers: Object.assign(Object.assign(Object.assign({}, (this.baseApiParams.headers || {})), (params1.headers || {})), ((params2 && params2.headers) || {})) });
+    }
+}
+exports.HttpClient = HttpClient;
+/**
+ * @title Vapi API
+ * @version 1.0
+ * @contact
+ *
+ * API for talking AIs
+ */
+class Api extends HttpClient {
+    constructor() {
+        super(...arguments);
+        this.call = {
+            /**
+             * No description
+             *
+             * @tags Calls
+             * @name CallControllerFindAll
+             * @summary List Calls
+             * @request GET:/call
+             */
+            callControllerFindAll: (params = {}) => this.request(Object.assign({ path: `/call`, method: "GET", format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Calls
+             * @name CallControllerFindOne
+             * @summary Get Call
+             * @request GET:/call/{id}
+             */
+            callControllerFindOne: (id, params = {}) => this.request(Object.assign({ path: `/call/${id}`, method: "GET", format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Calls
+             * @name CallControllerCreatePhoneCall
+             * @summary Create Phone Call
+             * @request POST:/call/phone
+             */
+            callControllerCreatePhoneCall: (data, params = {}) => this.request(Object.assign({ path: `/call/phone`, method: "POST", body: data, type: ContentType.Json, format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Calls
+             * @name CallControllerCreateWebCall
+             * @summary Create Web Call
+             * @request POST:/call/web
+             */
+            callControllerCreateWebCall: (data, params = {}) => this.request(Object.assign({ path: `/call/web`, method: "POST", body: data, type: ContentType.Json, format: "json" }, params)),
+        };
+        this.agent = {
+            /**
+             * No description
+             *
+             * @tags Agents
+             * @name AgentControllerCreate
+             * @summary Create Agent
+             * @request POST:/agent
+             */
+            agentControllerCreate: (data, params = {}) => this.request(Object.assign({ path: `/agent`, method: "POST", body: data, type: ContentType.Json, format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Agents
+             * @name AgentControllerFindAll
+             * @summary List Agents
+             * @request GET:/agent
+             */
+            agentControllerFindAll: (params = {}) => this.request(Object.assign({ path: `/agent`, method: "GET", format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Agents
+             * @name AgentControllerFindOne
+             * @summary Get Agent
+             * @request GET:/agent/{id}
+             */
+            agentControllerFindOne: (id, params = {}) => this.request(Object.assign({ path: `/agent/${id}`, method: "GET", format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Agents
+             * @name AgentControllerUpdate
+             * @summary Update Agent
+             * @request PATCH:/agent/{id}
+             */
+            agentControllerUpdate: (id, data, params = {}) => this.request(Object.assign({ path: `/agent/${id}`, method: "PATCH", body: data, type: ContentType.Json, format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Agents
+             * @name AgentControllerRemove
+             * @summary Delete Agent
+             * @request DELETE:/agent/{id}
+             */
+            agentControllerRemove: (id, params = {}) => this.request(Object.assign({ path: `/agent/${id}`, method: "DELETE" }, params)),
+        };
+        this.phoneNumber = {
+            /**
+             * No description
+             *
+             * @tags Phone Numbers
+             * @name PhoneNumberControllerBuy
+             * @summary Buy Phone Number
+             * @request POST:/phone-number/buy
+             */
+            phoneNumberControllerBuy: (data, params = {}) => this.request(Object.assign({ path: `/phone-number/buy`, method: "POST", body: data, type: ContentType.Json, format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Phone Numbers
+             * @name PhoneNumberControllerImport
+             * @summary Import Twilio Number
+             * @request POST:/phone-number/import
+             */
+            phoneNumberControllerImport: (data, params = {}) => this.request(Object.assign({ path: `/phone-number/import`, method: "POST", body: data, type: ContentType.Json, format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Phone Numbers
+             * @name PhoneNumberControllerFindAll
+             * @summary List Phone Numbers
+             * @request GET:/phone-number
+             */
+            phoneNumberControllerFindAll: (params = {}) => this.request(Object.assign({ path: `/phone-number`, method: "GET", format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Phone Numbers
+             * @name PhoneNumberControllerFindOne
+             * @summary Get Phone Number
+             * @request GET:/phone-number/{id}
+             */
+            phoneNumberControllerFindOne: (id, params = {}) => this.request(Object.assign({ path: `/phone-number/${id}`, method: "GET", format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Phone Numbers
+             * @name PhoneNumberControllerUpdate
+             * @summary Update Phone Number
+             * @request PATCH:/phone-number/{id}
+             */
+            phoneNumberControllerUpdate: (id, data, params = {}) => this.request(Object.assign({ path: `/phone-number/${id}`, method: "PATCH", body: data, type: ContentType.Json, format: "json" }, params)),
+            /**
+             * No description
+             *
+             * @tags Phone Numbers
+             * @name PhoneNumberControllerRemove
+             * @summary Delete Phone Number
+             * @request DELETE:/phone-number/{id}
+             */
+            phoneNumberControllerRemove: (id, params = {}) => this.request(Object.assign({ path: `/phone-number/${id}`, method: "DELETE" }, params)),
+        };
+    }
+}
+exports.Api = Api;

package/dist/client.d.ts

@@ -0,0 +1,2 @@
+import { Api } from "./api";
+export declare const client: Api<unknown>;

package/dist/client.js

@@ -0,0 +1,29 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = void 0;
+const api_1 = require("./api");
+const api = new api_1.Api({
+    baseUrl: "https://api.vapi.ai",
+    baseApiParams: {
+        secure: true,
+    },
+    securityWorker: (securityData) => __awaiter(void 0, void 0, void 0, function* () {
+        if (securityData) {
+            return {
+                headers: {
+                    Authorization: `Bearer ${securityData}`,
+                },
+            };
+        }
+    }),
+});
+exports.client = api;

package/dist/player.d.ts

@@ -0,0 +1,10 @@
+export declare class ContinuousPlayer {
+    private audioCtx;
+    private nextStartTime;
+    private audioQueue;
+    private crossFadeDuration;
+    constructor(crossFadeDuration?: number);
+    private createQueue;
+    playChunk(audioData: ArrayBuffer): void;
+    clear(): Promise<void>;
+}

package/dist/player.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContinuousPlayer = void 0;
+const async_1 = require("async"); // You need to install the async package
+class ContinuousPlayer {
+    constructor(crossFadeDuration = 0.5) {
+        this.audioCtx = new AudioContext();
+        this.nextStartTime = 0;
+        this.audioQueue = this.createQueue();
+        this.crossFadeDuration = crossFadeDuration;
+    }
+    createQueue() {
+        return (0, async_1.queue)((audioPromise, callback) => __awaiter(this, void 0, void 0, function* () {
+            const audioBuffer = yield audioPromise;
+            const source = this.audioCtx.createBufferSource();
+            source.buffer = audioBuffer;
+            source.connect(this.audioCtx.destination);
+            // Create a gain node for crossfading
+            const gainNode = this.audioCtx.createGain();
+            source.connect(gainNode);
+            gainNode.connect(this.audioCtx.destination);
+            // Start the source at the next start time
+            source.start(this.nextStartTime);
+            // Schedule the crossfade
+            gainNode.gain.setValueAtTime(0, this.nextStartTime);
+            gainNode.gain.linearRampToValueAtTime(1, this.nextStartTime + this.crossFadeDuration);
+            gainNode.gain.setValueAtTime(1, this.nextStartTime + audioBuffer.duration - this.crossFadeDuration);
+            gainNode.gain.linearRampToValueAtTime(0, this.nextStartTime + audioBuffer.duration);
+            source.onended = () => {
+                this.nextStartTime += audioBuffer.duration;
+                callback();
+            };
+        }), 1);
+    }
+    playChunk(audioData) {
+        const decodePromise = this.audioCtx.decodeAudioData(audioData);
+        this.audioQueue.push(decodePromise);
+    }
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.audioQueue.kill();
+            this.audioQueue = this.createQueue();
+            this.nextStartTime = 0;
+        });
+    }
+}
+exports.ContinuousPlayer = ContinuousPlayer;

package/dist/vapi.d.ts

@@ -0,0 +1,13 @@
+import { CreateAgentDTO } from "./api";
+export default class Vapi {
+    private started;
+    private ws;
+    private mediaRecorder;
+    private player;
+    constructor(apiToken: string);
+    start(agent: CreateAgentDTO): void;
+    private startRecording;
+    private onMessage;
+    clear(): void;
+    stop(): void;
+}

package/dist/vapi.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const player_1 = require("./player");
+const client_1 = require("./client");
+const base64_arraybuffer_1 = require("base64-arraybuffer");
+class Vapi {
+    constructor(apiToken) {
+        this.started = false;
+        this.ws = null;
+        this.mediaRecorder = null;
+        this.player = new player_1.ContinuousPlayer();
+        client_1.client.setSecurityData(apiToken);
+    }
+    start(agent) {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        client_1.client.call
+            .callControllerCreateWebCall({
+            agent,
+        })
+            .then(({ data }) => {
+            const { callId, url } = data;
+            const socket = new WebSocket(url);
+            this.ws = socket;
+            socket.onopen = () => {
+                socket.send(JSON.stringify({ event: "start", callId }));
+                this.startRecording();
+            };
+            socket.onmessage = (event) => {
+                if (!socket)
+                    return;
+                this.onMessage(socket, event);
+            };
+            socket.onclose = () => {
+                this.stop();
+            };
+        })
+            .catch((error) => {
+            console.error(error);
+        });
+    }
+    startRecording() {
+        navigator.mediaDevices.getUserMedia({ audio: true }).then((stream) => {
+            this.mediaRecorder = new MediaRecorder(stream, {
+                mimeType: "audio/webm;codecs=opus",
+            });
+            this.mediaRecorder.start(100);
+            this.mediaRecorder.ondataavailable = (event) => {
+                if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                    this.ws.send(event.data);
+                }
+            };
+        });
+    }
+    onMessage(ws, event) {
+        const data = JSON.parse(event.data);
+        if (data.event === "media") {
+            const audioData = (0, base64_arraybuffer_1.decode)(data.media.payload);
+            this.player.playChunk(audioData);
+        }
+        if (data.event === "clear") {
+            this.clear();
+        }
+    }
+    clear() {
+        this.player.clear();
+    }
+    stop() {
+        this.started = false;
+        if (this.ws) {
+            this.ws.close();
+        }
+        this.ws = null;
+        if (this.mediaRecorder) {
+            this.mediaRecorder.stop();
+        }
+        this.mediaRecorder = null;
+    }
+}
+exports.default = Vapi;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@vapi-ai/web",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/vapi.js",
+  "types": "dist/vapi.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc && tsc --declaration",
+    "start": "npm run generate-api && npm run build && node dist/vapi.js",
+    "generate-api": "npx swagger-typescript-api -p https://api-tv2l.onrender.com/api-json -o . -n api.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VapiAI/snippet.git"
+  },
+  "author": "vapi",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/VapiAI/snippet/issues"
+  },
+  "homepage": "https://github.com/VapiAI/snippet#readme",
+  "dependencies": {
+    "async": "^3.2.4",
+    "base64-arraybuffer": "^1.0.2",
+    "extendable-media-recorder": "^9.1.0",
+    "extendable-media-recorder-wav-encoder": "^7.0.96",
+    "msr": "^1.3.4",
+    "openai": "^4.0.1",
+    "standardized-audio-context": "^25.3.56",
+    "swagger-typescript-api": "^13.0.3"
+  },
+  "devDependencies": {
+    "@types/async": "^3.2.21",
+    "@types/node": "^20.6.0",
+    "@types/ws": "^8.5.5"
+  }
+}

package/player.ts

@@ -0,0 +1,66 @@
+import { QueueObject, queue } from "async"; // You need to install the async package
+
+export class ContinuousPlayer {
+  private audioCtx: AudioContext;
+  private nextStartTime: number;
+  private audioQueue: QueueObject<Promise<AudioBuffer>>;
+  private crossFadeDuration: number; // Duration of the crossfade
+
+  constructor(crossFadeDuration = 0.5) {
+    this.audioCtx = new AudioContext();
+    this.nextStartTime = 0;
+    this.audioQueue = this.createQueue();
+    this.crossFadeDuration = crossFadeDuration;
+  }
+
+  private createQueue() {
+    return queue(
+      async (audioPromise: Promise<AudioBuffer>, callback: Function) => {
+        const audioBuffer = await audioPromise;
+        const source = this.audioCtx.createBufferSource();
+        source.buffer = audioBuffer;
+        source.connect(this.audioCtx.destination);
+
+        // Create a gain node for crossfading
+        const gainNode = this.audioCtx.createGain();
+        source.connect(gainNode);
+        gainNode.connect(this.audioCtx.destination);
+
+        // Start the source at the next start time
+        source.start(this.nextStartTime);
+
+        // Schedule the crossfade
+        gainNode.gain.setValueAtTime(0, this.nextStartTime);
+        gainNode.gain.linearRampToValueAtTime(
+          1,
+          this.nextStartTime + this.crossFadeDuration
+        );
+        gainNode.gain.setValueAtTime(
+          1,
+          this.nextStartTime + audioBuffer.duration - this.crossFadeDuration
+        );
+        gainNode.gain.linearRampToValueAtTime(
+          0,
+          this.nextStartTime + audioBuffer.duration
+        );
+
+        source.onended = () => {
+          this.nextStartTime += audioBuffer.duration;
+          callback();
+        };
+      },
+      1
+    );
+  }
+
+  playChunk(audioData: ArrayBuffer) {
+    const decodePromise = this.audioCtx.decodeAudioData(audioData);
+    this.audioQueue.push(decodePromise);
+  }
+
+  async clear() {
+    this.audioQueue.kill();
+    this.audioQueue = this.createQueue();
+    this.nextStartTime = 0;
+  }
+}