@fonoster/autopilot 0.5.4 → 0.7.0

package/dist/machine/machine.js

@@ -0,0 +1,111 @@
+"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.machine = void 0;
+/*
+ * Copyright (C) 2024 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 xstate_1 = require("xstate");
+const types_1 = require("./types");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+exports.machine = (0, xstate_1.setup)({
+    types: types_1.types,
+    actions: {
+        sendGreeting: function (_a) {
+            return __awaiter(this, arguments, void 0, function* ({ context }) {
+                yield context.voice.answer();
+                yield context.voice.say(context.firstMessage);
+            });
+        },
+        interruptAISpeaking: function () {
+            logger.verbose("interruptAISpeaking");
+        },
+        processHumanRequest: function (_a) {
+            return __awaiter(this, arguments, void 0, function* ({ context, event }) {
+                const speech = event.speech;
+                logger.verbose("human request", { speech });
+                const response = yield context.assistant.invoke({
+                    text: speech
+                });
+                logger.verbose("assistant response", { response });
+                yield context.voice.say(response);
+            });
+        },
+        hangup: function (_a) {
+            return __awaiter(this, arguments, void 0, function* ({ context }) {
+                yield context.voice.hangup();
+            });
+        }
+    }
+}).createMachine({
+    context: ({ input }) => ({
+        firstMessage: input.firstMessage,
+        voice: input.voice,
+        assistant: input.assistant
+    }),
+    id: "fnAI",
+    initial: "welcome",
+    states: {
+        welcome: {
+            always: {
+                target: "active"
+            },
+            entry: {
+                type: "sendGreeting"
+            },
+            description: "The initial state where the AI greets the Human."
+        },
+        active: {
+            on: {
+                HUMAN_PROMPT: {
+                    target: "active",
+                    actions: {
+                        type: "processHumanRequest"
+                    },
+                    description: "This must be triggered when speech to text ends."
+                }
+            },
+            description: "The state where the AI is actively engaged in conversation."
+        },
+        humanSpeaking: {
+            always: {
+                target: "active"
+            },
+            entry: {
+                type: "interruptAISpeaking"
+            },
+            description: "The state where the AI detects Human speech while it is speaking."
+        },
+        hangup: {
+            type: "final",
+            description: "The final state where the AI terminates the conversation due to inactivity.",
+            entry: {
+                type: "hangup"
+            }
+        }
+    }
+});

package/dist/machine/types.d.ts

@@ -0,0 +1,21 @@
+import { VoiceResponse } from "@fonoster/voice";
+import { Assistant } from "../assistants/assistants";
+declare const types: {
+    context: {
+        firstMessage: string;
+        voice: VoiceResponse;
+        assistant: Assistant;
+    };
+    input: {
+        firstMessage: string;
+        voice: VoiceResponse;
+        assistant: Assistant;
+    };
+    events: {
+        type: "VOICE_DETECTED";
+    } | {
+        type: "HUMAN_PROMPT";
+        speech: string;
+    };
+};
+export { types };

package/dist/machine/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.types = void 0;
+const types = {
+    context: {},
+    input: {},
+    events: {}
+};
+exports.types = types;

package/dist/types.d.ts

@@ -1,41 +1,14 @@
-export interface ServerConfig {
-    port: number;
-    defaultLanguageCode: string;
-    eventsServerEnabled: boolean;
-    /**
-     * Enable file retention policy
-     *
-     * @default true
-     */
-    fileRetentionPolicyEnabled?: boolean;
-    /**
-     * Directory where the file retention policy will be executed
-     *
-     * @default os.tmpdir()
-     */
-    fileRetentionPolicyDirectory?: string;
-    /**
-     * Cron expression to run the file retention policy
-     *
-     * @default 0 0 * * *
-     * @see https://crontab.guru/#0_0_*_*_*
-     */
-    fileRetentionPolicyCronExpression?: string;
-    /**
-     * Max age in hours to keep files
-     *
-     * @default 24
-     */
-    fileRetentionPolicyMaxAge?: number;
-    /**
-     * File extension to be deleted
-     *
-     * @default .sln24
-     */
-    fileRetentionPolicyExtension?: string;
-}
-export declare enum TTSVendor {
-    GOOGLE = "google",
-    AMAZON = "amazon",
-    MICROSOFT = "microsoft"
-}
+import { VoiceResponse } from "@fonoster/voice";
+import { Model } from "./assistants/types";
+type AutopilotConfig = {
+    voice: VoiceResponse;
+    firstMessage: string;
+    assistantConfig: {
+        apiKey: string;
+        model: Model;
+        temperature: number;
+        maxTokens: number;
+        systemTemplate: string;
+    };
+};
+export { AutopilotConfig };

package/dist/types.js

@@ -1,9 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TTSVendor = void 0;
-var TTSVendor;
-(function (TTSVendor) {
-    TTSVendor["GOOGLE"] = "google";
-    TTSVendor["AMAZON"] = "amazon";
-    TTSVendor["MICROSOFT"] = "microsoft";
-})(TTSVendor || (exports.TTSVendor = TTSVendor = {}));

package/package.json

@@ -1,41 +1,43 @@
 {
   "name": "@fonoster/autopilot",
-  "version": "0.5.4",
+  "version": "0.7.0",
+  "description": "Voice AI for the Fonoster platform",
+  "author": "Pedro Sanders <psanders@fonoster.com>",
+  "homepage": "https://github.com/fonoster/fonoster#readme",
   "license": "MIT",
   "main": "dist/index",
   "types": "dist/index",
-  "bin": {
-    "run": "./bin/run",
-    "rox": "./bin/run"
+  "directories": {
+    "src": "src",
+    "test": "test"
   },
   "scripts": {
-    "build": "tsc --build ./tsconfig.json"
-  },
-  "dependencies": {
-    "@fonoster/apps": "^0.5.4",
-    "@fonoster/googleasr": "^0.5.4",
-    "@fonoster/googletts": "^0.5.4",
-    "@fonoster/logger": "^0.5.4",
-    "@fonoster/secrets": "^0.5.4",
-    "@fonoster/voice": "^0.5.4",
-    "@google-cloud/dialogflow": "^4.3.1",
-    "@google-cloud/dialogflow-cx": "^2.13.0",
-    "date-fns": "^2.29.3",
-    "nanoid": "^3.1.25",
-    "node-cron": "^3.0.2",
-    "pb-util": "^1.0.2",
-    "uuid": "^8.3.2",
-    "ws": "^8.1.0"
-  },
-  "devDependencies": {
-    "@types/ws": "^7.4.7"
+    "prebuild": "rimraf ./dist tsconfig.tsbuildinfo",
+    "build": "tsc -b tsconfig.json",
+    "clean": "rimraf ./dist node_modules tsconfig.tsbuildinfo"
   },
   "files": [
-    "/bin",
-    "/dist"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a1dae664944ab191e925e49346e0916f8c8347a1"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fonoster/fonoster.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fonoster/fonoster/issues"
+  },
+  "dependencies": {
+    "@fonoster/logger": "^0.7.0",
+    "@fonoster/voice": "^0.7.0",
+    "@langchain/openai": "^0.2.7",
+    "dotenv": "^16.4.5",
+    "xstate": "^5.17.3"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.4"
+  },
+  "gitHead": "afa950ace3b1d022b6dc8be0c3b87a6b8a5ba3c5"
 }

package/dist/cerebro/cerebro.d.ts

@@ -1,42 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { EffectsManager } from "./effects";
-import { Intent, IntentsEngine } from "../intents/types";
-import { SGatherStream, VoiceRequest, VoiceResponse } from "@fonoster/voice";
-import { CerebroConfig, CerebroStatus } from "./types";
-import Events from "events";
-export declare class Cerebro {
-    voiceResponse: VoiceResponse;
-    cerebroEvents: Events;
-    voiceRequest: VoiceRequest;
-    status: CerebroStatus;
-    activationTimeout: number;
-    maxIteractionsBeforeHangup: number;
-    failedInteractions: number;
-    activeTimer: NodeJS.Timer;
-    interactionTimer: NodeJS.Timer;
-    intentsEngine: IntentsEngine;
-    stream: SGatherStream;
-    config: CerebroConfig;
-    lastIntent: Intent;
-    effects: EffectsManager;
-    interactionsTimer: NodeJS.Timeout;
-    isCallHandover: boolean;
-    isDead: boolean;
-    constructor(config: CerebroConfig);
-    wake(): Promise<void>;
-    sleep(): Promise<void>;
-    startActiveTimer(): void;
-    resetActiveTimer(): void;
-    /**
-     * Start the interactions timer
-     * If the user doesn't say anything we should play the welcome message
-     * If it gets played twice many times we should hangup
-     * If the user says something we should reset the timer
-     * If we just finish an effect we should reset the timer
-     */
-    startInteractionTimer(): void;
-    resetInteractionTimer(): void;
-    stopPlayback(): Promise<void>;
-    cleanup(): Promise<void>;
-}

package/dist/cerebro/cerebro.js

@@ -1,266 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cerebro = void 0;
-/* eslint-disable require-jsdoc */
-/*
- * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
- * http://github.com/fonoster/rox
- *
- * This file is part of Rox AI
- *
- * 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 effects_1 = require("./effects");
-const types_1 = require("./types");
-const util_1 = require("../util");
-const types_2 = require("../events/types");
-const logger_1 = require("@fonoster/logger");
-const events_1 = __importDefault(require("events"));
-const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
-class Cerebro {
-    voiceResponse;
-    cerebroEvents;
-    voiceRequest;
-    status;
-    activationTimeout;
-    maxIteractionsBeforeHangup = 2;
-    failedInteractions = 0;
-    activeTimer;
-    interactionTimer;
-    intentsEngine;
-    stream;
-    config;
-    lastIntent;
-    effects;
-    interactionsTimer;
-    isCallHandover = false;
-    isDead = false;
-    constructor(config) {
-        this.voiceResponse = config.voiceResponse;
-        this.voiceRequest = config.voiceRequest;
-        this.cerebroEvents = new events_1.default();
-        this.status = types_1.CerebroStatus.SLEEP;
-        this.activationTimeout = config.activationTimeout || 15000;
-        this.intentsEngine = config.intentsEngine;
-        this.effects = new effects_1.EffectsManager({
-            playbackId: config.voiceConfig.playbackId,
-            eventsClient: config.eventsClient,
-            voice: config.voiceResponse,
-            voiceConfig: config.voiceConfig,
-            activationIntentId: config.activationIntentId,
-            transfer: config.transfer
-        });
-        this.config = config;
-    }
-    // Subscribe to events
-    async wake() {
-        this.status = types_1.CerebroStatus.AWAKE_PASSIVE;
-        // This timer becomes active only if we don't have an activation intent
-        if (!this.config.activationIntentId) {
-            this.startInteractionTimer();
-        }
-        this.voiceResponse.on("error", (error) => {
-            this.cerebroEvents.emit("error", error);
-            (0, logger_1.ulogger)({
-                accessKeyId: this.voiceRequest.accessKeyId,
-                eventType: logger_1.ULogType.APP,
-                level: "error",
-                message: error.message
-            });
-        });
-        const speechConfig = { source: "speech,dtmf" };
-        if (this.config.alternativeLanguageCode) {
-            speechConfig.model = "command_and_search";
-            speechConfig.alternativeLanguageCodes = [
-                this.config.alternativeLanguageCode
-            ];
-        }
-        this.stream = await this.voiceResponse.sgather(speechConfig);
-        this.stream.on("transcript", async (data) => {
-            if (data.isFinal && data.transcript) {
-                logger.verbose("clear interactions timer", {
-                    sessionId: this.voiceRequest.sessionId
-                });
-                clearTimeout(this.interactionsTimer);
-                const intent = await this.intentsEngine.findIntent(data.transcript, {
-                    telephony: {
-                        caller_id: this.voiceRequest.callerNumber
-                    }
-                });
-                logger.verbose("cerebro received new transcription from user", {
-                    sessionId: this.voiceRequest.sessionId,
-                    text: data.transcript,
-                    ref: intent.ref,
-                    confidence: intent.confidence
-                });
-                if (intent.effects.find((e) => e.type === "hangup") ||
-                    intent.effects.find((e) => e.type === "transfer")) {
-                    logger.verbose("call hand over: stop all the timers and close the stream", {
-                        sessionId: this.voiceRequest.sessionId
-                    });
-                    clearTimeout(this.activeTimer);
-                    clearTimeout(this.interactionsTimer);
-                    this.voiceResponse.closeMediaPipe();
-                    this.isCallHandover = true;
-                }
-                await this.effects.invokeEffects(intent, this.status, async () => {
-                    await this.stopPlayback();
-                    if (this.config.activationIntentId === intent.ref) {
-                        (0, util_1.sendClientEvent)(this.config.eventsClient, {
-                            eventName: types_2.CLIENT_EVENTS.RECOGNIZING
-                        });
-                        if (this.status === types_1.CerebroStatus.AWAKE_ACTIVE) {
-                            this.resetActiveTimer();
-                        }
-                        else {
-                            this.startActiveTimer();
-                        }
-                    }
-                }, () => {
-                    logger.verbose("invokeEffects cleanup callback", {
-                        sessionId: this.voiceRequest.sessionId
-                    });
-                    this.cleanup();
-                });
-                if (this.isDead || this.isCallHandover) {
-                    try {
-                        logger.verbose("the call was handover or cerebro was cleaned up", {
-                            sessionId: this.voiceRequest.sessionId
-                        });
-                        this.voiceResponse.hangup();
-                    }
-                    catch (e) {
-                        // All we can do is try as the call may have already been hung up
-                    }
-                    return;
-                }
-                logger.verbose("cerebro finished processing intent effects", {
-                    sessionId: this.voiceRequest.sessionId
-                });
-                // Reset the interactions timer
-                if (!this.config.activationIntentId) {
-                    this.resetInteractionTimer();
-                }
-                // WARNING: It doesn't appear that we are using this anywhere
-                this.lastIntent = intent;
-            }
-        });
-    }
-    // Unsubscribe from events
-    async sleep() {
-        logger.verbose("cerebro timeout and is going to sleep");
-        await this.voiceResponse.closeMediaPipe();
-        this.stream.close();
-        this.status = types_1.CerebroStatus.SLEEP;
-    }
-    startActiveTimer() {
-        this.status = types_1.CerebroStatus.AWAKE_ACTIVE;
-        this.activeTimer = setTimeout(() => {
-            this.status = types_1.CerebroStatus.AWAKE_PASSIVE;
-            (0, util_1.sendClientEvent)(this.config.eventsClient, {
-                eventName: types_2.CLIENT_EVENTS.RECOGNIZING_FINISHED
-            });
-            logger.verbose("cerebro changed awake status", { status: this.status });
-        }, this.activationTimeout);
-        logger.verbose("cerebro changed awake status", { status: this.status });
-    }
-    resetActiveTimer() {
-        logger.verbose("cerebro is reseting awake status");
-        clearTimeout(this.activeTimer);
-        this.startActiveTimer();
-    }
-    /**
-     * Start the interactions timer
-     * If the user doesn't say anything we should play the welcome message
-     * If it gets played twice many times we should hangup
-     * If the user says something we should reset the timer
-     * If we just finish an effect we should reset the timer
-     */
-    startInteractionTimer() {
-        logger.verbose("cerebro is starting interactions timer", {
-            sessionId: this.voiceRequest.sessionId
-        });
-        this.interactionsTimer = setInterval(async () => {
-            this.failedInteractions++;
-            logger.verbose("cerebro is counting interactions", {
-                sessionId: this.voiceRequest.sessionId,
-                failedInteractions: this.failedInteractions
-            });
-            // Fix hard coded intent
-            let intentId = "welcome";
-            if (this.failedInteractions >= this.maxIteractionsBeforeHangup) {
-                logger.verbose("there was no interaction so for a long time so we hangup", {
-                    sessionId: this.voiceRequest.sessionId
-                });
-                // Fix hard coded intent
-                intentId = "goodbye";
-                clearTimeout(this.interactionsTimer);
-            }
-            const intent = await this.intentsEngine.findIntentWithEvent(intentId, {
-                telephony: {
-                    caller_id: this.voiceRequest.callerNumber
-                }
-            });
-            await this.effects.invokeEffects(intent, this.status, () => {
-                logger.verbose("invokeEffects callback", {
-                    sessionId: this.voiceRequest.sessionId
-                });
-            }, () => {
-                logger.verbose("invokeEffects cleanup callback", {
-                    sessionId: this.voiceRequest.sessionId
-                });
-                this.cleanup();
-            });
-        }, this.activationTimeout);
-    }
-    resetInteractionTimer() {
-        logger.verbose("cerebro is reseting interactions timer", {
-            sessionId: this.voiceRequest.sessionId
-        });
-        // Reset the failed interactions timer
-        this.failedInteractions = 0;
-        clearTimeout(this.interactionsTimer);
-        this.startInteractionTimer();
-    }
-    async stopPlayback() {
-        const { playbackId } = this.config.voiceConfig;
-        if (playbackId) {
-            try {
-                const playbackControl = this.voiceResponse.playback(playbackId);
-                logger.verbose("cerebro is stoping playback", { playbackId });
-                await playbackControl.stop();
-            }
-            catch (e) {
-                (0, logger_1.ulogger)({
-                    accessKeyId: this.voiceRequest.accessKeyId,
-                    eventType: logger_1.ULogType.APP,
-                    level: "error",
-                    message: e.message
-                });
-            }
-        }
-    }
-    // Cleanup all timers and events
-    async cleanup() {
-        this.isDead = true;
-        await this.voiceResponse.closeMediaPipe();
-        this.stream.close();
-        this.cerebroEvents.removeAllListeners();
-        clearTimeout(this.activeTimer);
-        clearTimeout(this.interactionsTimer);
-    }
-}
-exports.Cerebro = Cerebro;

package/dist/cerebro/effects.d.ts

@@ -1,11 +0,0 @@
-import { VoiceResponse } from "@fonoster/voice";
-import { Intent } from "../intents/types";
-import { EffectsManagerConfig, CerebroStatus, Effect } from "./types";
-export declare class EffectsManager {
-    voice: VoiceResponse;
-    config: EffectsManagerConfig;
-    constructor(config: EffectsManagerConfig);
-    invokeEffects(intent: Intent, status: CerebroStatus, activateCallback: () => void, cleanupCallback: () => void): Promise<void>;
-    run(effect: Effect): Promise<void>;
-    transferEffect(effect: Effect): Promise<void>;
-}