@fonoster/autopilot 0.27.0 → 0.30.0

package/dist/machine/machine.d.ts

@@ -1,408 +0,0 @@
-declare const machine: import("xstate").StateMachine<any, import("./types").AutopilotEvents, {
-    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, {
-        context: import("./types").AutopilotContext;
-    }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, {
-        context: import("./types").AutopilotContext;
-    }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, {
-        context: import("./types").AutopilotContext;
-    }, import("xstate").EventObject>>;
-}, import("xstate").Values<{
-    doProcessUserRequest: {
-        src: "doProcessUserRequest";
-        logic: import("xstate").PromiseActorLogic<void, {
-            context: import("./types").AutopilotContext;
-        }, import("xstate").EventObject>;
-        id: string;
-    };
-    doGreetUser: {
-        src: "doGreetUser";
-        logic: import("xstate").PromiseActorLogic<void, {
-            context: import("./types").AutopilotContext;
-        }, import("xstate").EventObject>;
-        id: string;
-    };
-    doAnnounceIdleTimeout: {
-        src: "doAnnounceIdleTimeout";
-        logic: import("xstate").PromiseActorLogic<void, {
-            context: import("./types").AutopilotContext;
-        }, import("xstate").EventObject>;
-        id: string;
-    };
-}>, import("xstate").Values<{
-    appendSpeech: {
-        type: "appendSpeech";
-        params: unknown;
-    };
-    cleanSpeech: {
-        type: "cleanSpeech";
-        params: unknown;
-    };
-    increaseIdleTimeoutCount: {
-        type: "increaseIdleTimeoutCount";
-        params: unknown;
-    };
-    resetIdleTimeoutCount: {
-        type: "resetIdleTimeoutCount";
-        params: unknown;
-    };
-    resetState: {
-        type: "resetState";
-        params: unknown;
-    };
-    goodbye: {
-        type: "goodbye";
-        params: unknown;
-    };
-    announceSystemError: {
-        type: "announceSystemError";
-        params: unknown;
-    };
-    interruptPlayback: {
-        type: "interruptPlayback";
-        params: unknown;
-    };
-}>, import("xstate").Values<{
-    idleTimeoutCountExceedsMax: {
-        type: "idleTimeoutCountExceedsMax";
-        params: unknown;
-    };
-    hasSpeechResult: {
-        type: "hasSpeechResult";
-        params: unknown;
-    };
-}>, "IDLE_TIMEOUT" | "MAX_SPEECH_WAIT_TIMEOUT" | "MAX_SESSION_DURATION", "hangup" | "greeting" | "idle" | "listeningToUser" | "announcingIdleTimeout" | "waitingForSpeechTimeout" | "processingUserRequest", string, {
-    conversationSettings: import("..").ConversationSettings;
-    languageModel: import("..").LanguageModel;
-    voice: import("..").Voice;
-}, {}, import("xstate").EventObject, import("xstate").MetaObject, {
-    readonly context: ({ input }: {
-        input: {
-            voice: import("..").Voice;
-            languageModel: import("..").LanguageModel;
-            conversationSettings: import("..").ConversationSettings;
-        };
-    }) => {
-        mediaSessionRef: string;
-        voice: import("..").Voice;
-        languageModel: import("..").LanguageModel;
-        speechBuffer: string;
-        firstMessage: string;
-        goodbyeMessage: string;
-        transferMessage: string;
-        transferPhoneNumber: string;
-        transferTimeout: number;
-        systemErrorMessage: string;
-        idleMessage: string;
-        idleTimeout: number;
-        maxIdleTimeoutCount: number;
-        idleTimeoutCount: number;
-        maxSpeechWaitTimeout: number;
-        allowUserBargeIn: boolean;
-        sessionStartTime: number;
-        maxSessionDuration: number;
-        initialDtmf: string;
-        previousState: any;
-        hasLateSpeech: boolean;
-        isFirstTurn: boolean;
-    };
-    readonly id: "fnAI";
-    readonly initial: "greeting";
-    readonly states: {
-        readonly greeting: {
-            readonly invoke: {
-                readonly src: "doGreetUser";
-                readonly description: "Answer the call and play the first message";
-                readonly input: ({ context }: {
-                    context: any;
-                    event: import("./types").AutopilotEvents;
-                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<any, import("./types").AutopilotEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("./types").AutopilotEvents, import("xstate").AnyEventObject>;
-                }) => {
-                    context: any;
-                };
-                readonly onDone: {
-                    readonly target: "idle";
-                    readonly description: "Transition to idle after the initial greeting.";
-                };
-                readonly onError: {
-                    readonly target: "idle";
-                };
-            };
-            readonly on: {
-                readonly SPEECH_START: {
-                    readonly target: "listeningToUser";
-                    readonly description: "The user barged in during the greeting.";
-                };
-            };
-        };
-        readonly idle: {
-            readonly entry: readonly [{
-                readonly type: "cleanSpeech";
-            }];
-            readonly on: {
-                readonly SPEECH_START: {
-                    readonly target: "listeningToUser";
-                    readonly description: "Event from VAD system.";
-                };
-            };
-            readonly after: {
-                readonly IDLE_TIMEOUT: readonly [{
-                    readonly target: "hangup";
-                    readonly actions: {
-                        readonly type: "goodbye";
-                    };
-                    readonly guard: import("xstate/dist/declarations/src/guards").GuardPredicate<any, import("./types").AutopilotEvents, unknown, {
-                        type: "idleTimeoutCountExceedsMax";
-                        params: undefined;
-                    }>;
-                }, {
-                    readonly target: "announcingIdleTimeout";
-                }];
-            };
-        };
-        readonly announcingIdleTimeout: {
-            readonly entry: readonly [{
-                readonly type: "increaseIdleTimeoutCount";
-            }];
-            readonly invoke: {
-                readonly src: "doAnnounceIdleTimeout";
-                readonly description: "Play the idle message";
-                readonly input: ({ context }: {
-                    context: any;
-                    event: import("./types").AutopilotEvents;
-                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<any, import("./types").AutopilotEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("./types").AutopilotEvents, import("xstate").AnyEventObject>;
-                }) => {
-                    context: any;
-                };
-                readonly onDone: {
-                    readonly target: "idle";
-                    readonly description: "Re-arm the idle clock once the idle message finishes.";
-                };
-                readonly onError: {
-                    readonly target: "idle";
-                };
-            };
-            readonly on: {
-                readonly SPEECH_START: {
-                    readonly target: "listeningToUser";
-                    readonly description: "The user spoke while the idle message was playing.";
-                };
-            };
-        };
-        readonly listeningToUser: {
-            readonly entry: readonly [{
-                readonly type: "interruptPlayback";
-            }, {
-                readonly type: "resetIdleTimeoutCount";
-            }, import("xstate").ActionFunction<any, import("./types").AutopilotEvents, import("./types").AutopilotEvents, undefined, import("xstate").Values<{
-                doProcessUserRequest: {
-                    src: "doProcessUserRequest";
-                    logic: import("xstate").PromiseActorLogic<void, {
-                        context: import("./types").AutopilotContext;
-                    }, import("xstate").EventObject>;
-                    id: string;
-                };
-                doGreetUser: {
-                    src: "doGreetUser";
-                    logic: import("xstate").PromiseActorLogic<void, {
-                        context: import("./types").AutopilotContext;
-                    }, import("xstate").EventObject>;
-                    id: string;
-                };
-                doAnnounceIdleTimeout: {
-                    src: "doAnnounceIdleTimeout";
-                    logic: import("xstate").PromiseActorLogic<void, {
-                        context: import("./types").AutopilotContext;
-                    }, import("xstate").EventObject>;
-                    id: string;
-                };
-            }>, never, never, never, never>];
-            readonly on: {
-                readonly SPEECH_RESULT: {
-                    readonly target: "waitingForSpeechTimeout";
-                    readonly actions: {
-                        readonly type: "appendSpeech";
-                    };
-                    readonly description: "Append final speech and process the request.";
-                    readonly reenter: true;
-                };
-            };
-            readonly after: {
-                readonly IDLE_TIMEOUT: readonly [{
-                    readonly target: "hangup";
-                    readonly actions: {
-                        readonly type: "goodbye";
-                    };
-                    readonly guard: import("xstate/dist/declarations/src/guards").GuardPredicate<any, import("./types").AutopilotEvents, unknown, {
-                        type: "idleTimeoutCountExceedsMax";
-                        params: undefined;
-                    }>;
-                }, {
-                    readonly target: "announcingIdleTimeout";
-                }];
-            };
-        };
-        readonly waitingForSpeechTimeout: {
-            readonly on: {
-                readonly SPEECH_START: {
-                    readonly target: "listeningToUser";
-                    readonly description: "User started speaking again.";
-                    readonly guard: ({ context }: import("xstate/dist/declarations/src/guards").GuardArgs<any, {
-                        type: "SPEECH_START";
-                    }>) => any;
-                };
-                readonly SPEECH_RESULT: {
-                    readonly target: "waitingForSpeechTimeout";
-                    readonly description: "Capture late speech, but only once.";
-                    readonly guard: ({ context }: import("xstate/dist/declarations/src/guards").GuardArgs<any, {
-                        type: "SPEECH_RESULT";
-                        speech: string;
-                        responseTime: number;
-                    }>) => boolean;
-                    readonly actions: readonly [{
-                        readonly type: "appendSpeech";
-                    }, import("xstate").ActionFunction<any, {
-                        type: "SPEECH_RESULT";
-                        speech: string;
-                        responseTime: number;
-                    }, import("./types").AutopilotEvents, undefined, import("xstate").Values<{
-                        doProcessUserRequest: {
-                            src: "doProcessUserRequest";
-                            logic: import("xstate").PromiseActorLogic<void, {
-                                context: import("./types").AutopilotContext;
-                            }, import("xstate").EventObject>;
-                            id: string;
-                        };
-                        doGreetUser: {
-                            src: "doGreetUser";
-                            logic: import("xstate").PromiseActorLogic<void, {
-                                context: import("./types").AutopilotContext;
-                            }, import("xstate").EventObject>;
-                            id: string;
-                        };
-                        doAnnounceIdleTimeout: {
-                            src: "doAnnounceIdleTimeout";
-                            logic: import("xstate").PromiseActorLogic<void, {
-                                context: import("./types").AutopilotContext;
-                            }, import("xstate").EventObject>;
-                            id: string;
-                        };
-                    }>, never, never, never, never>];
-                };
-            };
-            readonly after: {
-                readonly MAX_SPEECH_WAIT_TIMEOUT: {
-                    readonly target: "processingUserRequest";
-                    readonly description: "This will give the person time to breathe and speak again.";
-                    readonly reenter: true;
-                };
-            };
-        };
-        readonly hangup: {
-            readonly type: "final";
-        };
-        readonly processingUserRequest: {
-            readonly on: {
-                readonly SPEECH_START: {
-                    readonly target: "listeningToUser";
-                    readonly description: "Event from VAD or similar system.";
-                    readonly guard: ({ context }: import("xstate/dist/declarations/src/guards").GuardArgs<any, {
-                        type: "SPEECH_START";
-                    }>) => any;
-                    readonly actions: readonly [{
-                        readonly type: "cleanSpeech";
-                    }];
-                };
-                readonly SPEECH_RESULT: {
-                    readonly target: "processingUserRequest";
-                    readonly description: "Capture only a single late speech across the entire request processing.";
-                    readonly guard: ({ context }: import("xstate/dist/declarations/src/guards").GuardArgs<any, {
-                        type: "SPEECH_RESULT";
-                        speech: string;
-                        responseTime: number;
-                    }>) => boolean;
-                    readonly actions: readonly [{
-                        readonly type: "interruptPlayback";
-                    }, {
-                        readonly type: "appendSpeech";
-                    }, import("xstate").ActionFunction<any, {
-                        type: "SPEECH_RESULT";
-                        speech: string;
-                        responseTime: number;
-                    }, import("./types").AutopilotEvents, undefined, import("xstate").Values<{
-                        doProcessUserRequest: {
-                            src: "doProcessUserRequest";
-                            logic: import("xstate").PromiseActorLogic<void, {
-                                context: import("./types").AutopilotContext;
-                            }, import("xstate").EventObject>;
-                            id: string;
-                        };
-                        doGreetUser: {
-                            src: "doGreetUser";
-                            logic: import("xstate").PromiseActorLogic<void, {
-                                context: import("./types").AutopilotContext;
-                            }, import("xstate").EventObject>;
-                            id: string;
-                        };
-                        doAnnounceIdleTimeout: {
-                            src: "doAnnounceIdleTimeout";
-                            logic: import("xstate").PromiseActorLogic<void, {
-                                context: import("./types").AutopilotContext;
-                            }, import("xstate").EventObject>;
-                            id: string;
-                        };
-                    }>, never, never, never, never>];
-                    readonly reenter: true;
-                };
-            };
-            readonly invoke: {
-                readonly src: "doProcessUserRequest";
-                readonly description: "Process the user request";
-                readonly input: ({ context }: {
-                    context: any;
-                    event: import("./types").AutopilotEvents;
-                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<any, import("./types").AutopilotEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("./types").AutopilotEvents, import("xstate").AnyEventObject>;
-                }) => {
-                    context: any;
-                };
-                readonly onDone: {
-                    readonly target: "listeningToUser";
-                    readonly reenter: true;
-                    readonly actions: readonly [{
-                        readonly type: "cleanSpeech";
-                    }, import("xstate").ActionFunction<any, import("xstate").DoneActorEvent<void, string>, import("./types").AutopilotEvents, undefined, import("xstate").Values<{
-                        doProcessUserRequest: {
-                            src: "doProcessUserRequest";
-                            logic: import("xstate").PromiseActorLogic<void, {
-                                context: import("./types").AutopilotContext;
-                            }, import("xstate").EventObject>;
-                            id: string;
-                        };
-                        doGreetUser: {
-                            src: "doGreetUser";
-                            logic: import("xstate").PromiseActorLogic<void, {
-                                context: import("./types").AutopilotContext;
-                            }, import("xstate").EventObject>;
-                            id: string;
-                        };
-                        doAnnounceIdleTimeout: {
-                            src: "doAnnounceIdleTimeout";
-                            logic: import("xstate").PromiseActorLogic<void, {
-                                context: import("./types").AutopilotContext;
-                            }, import("xstate").EventObject>;
-                            id: string;
-                        };
-                    }>, never, never, never, never>];
-                };
-            };
-        };
-    };
-    readonly after: {
-        readonly MAX_SESSION_DURATION: {
-            readonly target: ".hangup";
-            readonly actions: {
-                readonly type: "goodbye";
-            };
-        };
-    };
-}>;
-export { machine };

package/dist/machine/machine.js

@@ -1,206 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.machine = 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 xstate_1 = require("xstate");
-const xstate_2 = require("xstate");
-const context_1 = require("./context");
-const setup_1 = require("./setup");
-const machine = setup_1.machineSetup.createMachine({
-    context: context_1.context,
-    id: "fnAI",
-    initial: "greeting",
-    states: {
-        greeting: {
-            // The greeting is invoked (not fired-and-forgotten) so the machine only
-            // moves to "idle", and therefore only arms the idle clock, once the
-            // first message has been fully played.
-            invoke: {
-                src: "doGreetUser",
-                description: "Answer the call and play the first message",
-                input: ({ context }) => ({ context }),
-                onDone: {
-                    target: "idle",
-                    description: "Transition to idle after the initial greeting."
-                },
-                onError: {
-                    target: "idle"
-                }
-            },
-            on: {
-                SPEECH_START: {
-                    target: "listeningToUser",
-                    description: "The user barged in during the greeting."
-                }
-            }
-        },
-        idle: {
-            entry: [{ type: "cleanSpeech" }],
-            on: {
-                SPEECH_START: {
-                    target: "listeningToUser",
-                    description: "Event from VAD system."
-                }
-            },
-            after: {
-                IDLE_TIMEOUT: [
-                    {
-                        target: "hangup",
-                        actions: { type: "goodbye" },
-                        guard: (0, xstate_1.and)(["idleTimeoutCountExceedsMax"])
-                    },
-                    {
-                        target: "announcingIdleTimeout"
-                    }
-                ]
-            }
-        },
-        announcingIdleTimeout: {
-            // A dedicated state, with no IDLE_TIMEOUT of its own, so the idle clock
-            // is stopped while the idle message plays. It is re-armed only when the
-            // message finishes and the machine goes back to "idle". This prevents
-            // back-to-back idle announcements (and a premature hangup) when the
-            // idle timeout is short relative to the message duration.
-            entry: [{ type: "increaseIdleTimeoutCount" }],
-            invoke: {
-                src: "doAnnounceIdleTimeout",
-                description: "Play the idle message",
-                input: ({ context }) => ({ context }),
-                onDone: {
-                    target: "idle",
-                    description: "Re-arm the idle clock once the idle message finishes."
-                },
-                onError: {
-                    target: "idle"
-                }
-            },
-            on: {
-                SPEECH_START: {
-                    target: "listeningToUser",
-                    description: "The user spoke while the idle message was playing."
-                }
-            }
-        },
-        listeningToUser: {
-            entry: [
-                { type: "interruptPlayback" },
-                { type: "resetIdleTimeoutCount" },
-                (0, xstate_2.assign)({ hasLateSpeech: false })
-            ],
-            on: {
-                SPEECH_RESULT: {
-                    target: "waitingForSpeechTimeout",
-                    actions: {
-                        type: "appendSpeech"
-                    },
-                    description: "Append final speech and process the request.",
-                    reenter: true
-                }
-            },
-            after: {
-                IDLE_TIMEOUT: [
-                    {
-                        target: "hangup",
-                        actions: { type: "goodbye" },
-                        guard: (0, xstate_1.and)(["idleTimeoutCountExceedsMax"])
-                    },
-                    {
-                        target: "announcingIdleTimeout"
-                    }
-                ]
-            }
-        },
-        waitingForSpeechTimeout: {
-            on: {
-                SPEECH_START: {
-                    target: "listeningToUser",
-                    description: "User started speaking again.",
-                    guard: ({ context }) => context.allowUserBargeIn
-                },
-                SPEECH_RESULT: {
-                    target: "waitingForSpeechTimeout",
-                    description: "Capture late speech, but only once.",
-                    guard: ({ context }) => !context.hasLateSpeech,
-                    actions: [{ type: "appendSpeech" }, (0, xstate_2.assign)({ hasLateSpeech: true })]
-                }
-            },
-            after: {
-                MAX_SPEECH_WAIT_TIMEOUT: {
-                    target: "processingUserRequest",
-                    description: "This will give the person time to breathe and speak again.",
-                    reenter: true
-                }
-            }
-        },
-        hangup: {
-            type: "final"
-        },
-        processingUserRequest: {
-            on: {
-                SPEECH_START: {
-                    target: "listeningToUser",
-                    description: "Event from VAD or similar system.",
-                    guard: ({ context }) => context.allowUserBargeIn,
-                    // We assume that the user wants to steer the conversation
-                    // back to the agent so we clean the speech buffer
-                    actions: [{ type: "cleanSpeech" }]
-                },
-                SPEECH_RESULT: {
-                    target: "processingUserRequest",
-                    description: "Capture only a single late speech across the entire request processing.",
-                    guard: ({ context }) => context.allowUserBargeIn && !context.hasLateSpeech,
-                    actions: [
-                        { type: "interruptPlayback" },
-                        { type: "appendSpeech" },
-                        (0, xstate_2.assign)(({ self }) => {
-                            return {
-                                previousState: self.getSnapshot().value,
-                                hasLateSpeech: true
-                            };
-                        })
-                    ],
-                    reenter: true
-                }
-            },
-            invoke: {
-                src: "doProcessUserRequest",
-                description: "Process the user request",
-                input: ({ context }) => ({ context }),
-                onDone: {
-                    target: "listeningToUser",
-                    reenter: true,
-                    actions: [
-                        { type: "cleanSpeech" },
-                        (0, xstate_2.assign)({
-                            isFirstTurn: false
-                        })
-                    ]
-                }
-            }
-        }
-    },
-    after: {
-        MAX_SESSION_DURATION: {
-            target: ".hangup",
-            actions: { type: "goodbye" }
-        }
-    }
-});
-exports.machine = machine;