@kaltura-sdk/avatars 1.14.0

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-states/agent-recovery-monitor-state.d.ts

@@ -0,0 +1,28 @@
+export declare const agentRecoveryMonitorState: {
+    id: string;
+    on: {
+        AgentRecoveryTurnCompleted: ({
+            guard: "hadAvatarTypeInTurn";
+            actions: "resetAgentRecoveryRetryCount";
+        } | {
+            guard: "hasMoreRecoveryRetries";
+            actions: readonly ["incrementAgentRecoveryRetryCount", "sendReprocessTurn"];
+        } | {
+            guard: "justExceededRecoveryRetries";
+            actions: readonly ["incrementAgentRecoveryRetryCount", "showAgentRecoveryExhaustedNotification"];
+        })[];
+        RequestAgentTurnRecovery: {
+            actions: "sendReprocessTurn";
+        };
+    };
+    invoke: {
+        src: "agentRecoveryMonitor";
+        input: ({ context }: {
+            context: import("../../types").AvatarConnectionMachineContext;
+            event: import("../../types").AvatarConnectionMachineEvents;
+            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+        }) => {
+            logger: import("@unisphere/core").UnisphereLoggerType;
+        };
+    };
+};

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-states/captions-state.d.ts

@@ -0,0 +1,50 @@
+export declare const captionsState: {
+    id: string;
+    initial: string;
+    states: {
+        unknown: {
+            always: ({
+                guard: "isCaptionsEnabled";
+                target: string;
+            } | {
+                target: string;
+                guard?: undefined;
+            })[];
+        };
+        enabled: {
+            initial: string;
+            invoke: {
+                src: "onCaptions";
+                input: ({ context }: {
+                    context: import("../../types").AvatarConnectionMachineContext;
+                    event: import("../../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                    config: boolean | import("dist/unisphere/packages/unisphere/types/src").CaptionConfig;
+                };
+            }[];
+            states: {
+                visible: {
+                    on: {
+                        ToggleCaptions: {
+                            target: string;
+                        };
+                        CaptionStateUpdated: {
+                            actions: "setCaptionState";
+                        };
+                    };
+                };
+                hidden: {
+                    entry: "clearCaptionState";
+                    on: {
+                        ToggleCaptions: {
+                            target: string;
+                        };
+                    };
+                };
+            };
+        };
+        disabled: {};
+    };
+};

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-states/content-state.d.ts

@@ -0,0 +1,21 @@
+export declare const contentState: {
+    id: string;
+    invoke: {
+        src: "onAgentRawText";
+        input: ({ context }: {
+            context: import("../../types").AvatarConnectionMachineContext;
+            event: import("../../types").AvatarConnectionMachineEvents;
+            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+        }) => {
+            logger: import("@unisphere/core").UnisphereLoggerType;
+        };
+    }[];
+    on: {
+        SetContent: {
+            actions: readonly ["setContentData"];
+        };
+        AgentRawTextMessageCompleted: {
+            actions: readonly ["setContentData"];
+        };
+    };
+};

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-states/conversation-state.d.ts

@@ -0,0 +1,52 @@
+import { DisconnectReasons } from '@unisphere/genie-types';
+export declare const conversationState: {
+    id: string;
+    invoke: ({
+        src: "onConversationEnded";
+        input: ({ context }: {
+            context: import("../../types").AvatarConnectionMachineContext;
+            event: import("../../types").AvatarConnectionMachineEvents;
+            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+        }) => {
+            logger: import("@unisphere/core").UnisphereLoggerType;
+        };
+    } | {
+        src: "onAgentTalking";
+        input: ({ context }: {
+            context: import("../../types").AvatarConnectionMachineContext;
+            event: import("../../types").AvatarConnectionMachineEvents;
+            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+        }) => {
+            logger: import("@unisphere/core").UnisphereLoggerType;
+        };
+    } | {
+        src: "onConversationTimeWarning";
+        input: ({ context }: {
+            context: import("../../types").AvatarConnectionMachineContext;
+            event: import("../../types").AvatarConnectionMachineEvents;
+            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+        }) => {
+            logger: import("@unisphere/core").UnisphereLoggerType;
+        };
+    })[];
+    on: {
+        ConversationEndedReceived: {
+            actions: {
+                type: "setDisconnectData";
+                params: {
+                    reason: DisconnectReasons;
+                };
+            };
+            target: string;
+        };
+        AgentStartedTalkingReceived: {
+            actions: readonly ["setAgentTalking", "sendAvatarAnswerAnalyticsEvent"];
+        };
+        AgentFinishedTalkingReceived: {
+            actions: "setAgentTalking";
+        };
+        ConversationTimeWarningReceived: {
+            actions: "showTimeWarningNotification";
+        };
+    };
+};

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-states/genie-intellect-state.d.ts

@@ -0,0 +1,27 @@
+export declare const genieIntellectState: {
+    id: string;
+    on: {
+        SetDynamicVariables: {
+            actions: readonly ["setDynamicVariables", "sendUpdateGenieContext"];
+        };
+        AgentClientToolCallCompleted: {
+            actions: readonly ["logAgentClientToolCallResult"];
+        };
+        AgentClientToolCallLogged: {
+            actions: readonly ["recordClientToolCallLogEntry"];
+        };
+    };
+    invoke: {
+        src: "onAgentClientToolCall";
+        input: ({ context }: {
+            context: import("../../types").AvatarConnectionMachineContext;
+            event: import("../../types").AvatarConnectionMachineEvents;
+            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+        }) => {
+            logger: import("@unisphere/core").UnisphereLoggerType;
+            getClientToolHandler: import("dist/unisphere/packages/local/shared-utils/src").GetClientToolHandler;
+            ks: string;
+            threadId: string | null;
+        };
+    };
+};

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-states/kaltura-context-state.d.ts

@@ -0,0 +1,34 @@
+export declare const kalturaContextState: {
+    id: string;
+    initial: string;
+    states: {
+        unknown: {
+            always: ({
+                guard: "isKalturaContextEnabled";
+                target: string;
+            } | {
+                target: string;
+                guard?: undefined;
+            })[];
+        };
+        enabled: {
+            invoke: {
+                src: "onKalturaContextIsActiveChange";
+                input: ({ context }: {
+                    context: import("../../types").AvatarConnectionMachineContext;
+                    event: import("../../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                    pubSubService: import("@unisphere/runtime").PubSubServiceType;
+                };
+            };
+            on: {
+                SetKalturaContextActive: {
+                    actions: readonly ["setKalturaContextIsActive", "publishToggleKalturaContextActive", "sendUpdateGenieContext"];
+                };
+            };
+        };
+        disabled: {};
+    };
+};

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-states/pause-lifecycle-state.d.ts

@@ -0,0 +1,134 @@
+export declare const pauseLifecycleState: {
+    id: string;
+    initial: "idle";
+    states: {
+        idle: {
+            on: {
+                RequestAvatarPause: {
+                    target: "paused";
+                };
+                RequestAvatarPauseAfterSpeaking: {
+                    target: "pendingPause";
+                };
+            };
+        };
+        pendingPause: {
+            on: {
+                AgentFinishedTalkingReceived: {
+                    target: "paused";
+                };
+                RequestAvatarResume: {
+                    target: "idle";
+                };
+            };
+            always: {
+                guard: import("xstate").GuardPredicate<import("xstate").MachineContext, import("xstate").EventObject, unknown, {
+                    type: "isAgentTalking";
+                    params: undefined;
+                }>;
+                target: string;
+            };
+        };
+        paused: {
+            entry: ("sendPauseConversation" | "muteAsr" | "captureUserMuteState" | "sendTapToTalkEnd" | "raiseRequestTapToTalkEnd" | {
+                type: "setTapToTalkActive";
+                params: {
+                    active: boolean;
+                    startedAt?: undefined;
+                };
+            } | {
+                type: "setTapToTalkStartedAt";
+                params: {
+                    startedAt: null;
+                    active?: undefined;
+                };
+            })[];
+            invoke: {
+                src: "onPauseExpiryEvents";
+                input: ({ context }: {
+                    context: import("../../types").AvatarConnectionMachineContext;
+                    event: import("../../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+            }[];
+            on: {
+                PauseExpiryWarningReceived: {
+                    actions: readonly ["extendPauseTimeout"];
+                };
+                PauseSessionExpiredReceived: {
+                    target: "expired";
+                };
+                RequestAvatarResume: {
+                    target: "resuming";
+                };
+            };
+        };
+        expired: {
+            entry: readonly ["leaveAsr"];
+            invoke: {
+                src: "onSessionReadyForResume";
+                input: ({ context }: {
+                    context: import("../../types").AvatarConnectionMachineContext;
+                    event: import("../../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+            }[];
+            on: {
+                SessionReadyForResumeReceived: {
+                    target: "expiredServerReady";
+                };
+                RequestAvatarResume: {
+                    target: "waitingForServerReady";
+                };
+            };
+        };
+        expiredServerReady: {
+            on: {
+                RequestAvatarResume: {
+                    target: "#AvatarClient.connecting.reconnectingFromExpiry";
+                    actions: readonly ["sendResumeConversation"];
+                };
+            };
+        };
+        waitingForServerReady: {
+            invoke: {
+                src: "onSessionReadyForResume";
+                input: ({ context }: {
+                    context: import("../../types").AvatarConnectionMachineContext;
+                    event: import("../../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+            }[];
+            on: {
+                SessionReadyForResumeReceived: {
+                    target: "#AvatarClient.connecting.reconnectingFromExpiry";
+                    actions: readonly ["sendResumeConversation"];
+                };
+            };
+        };
+        resuming: {
+            entry: readonly ["unmuteAsr", "sendResumeConversation"];
+            invoke: {
+                src: "onConversationResumed";
+                input: ({ context }: {
+                    context: import("../../types").AvatarConnectionMachineContext;
+                    event: import("../../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+            }[];
+            on: {
+                ConversationResumedReceived: {
+                    target: "idle";
+                };
+            };
+        };
+    };
+};

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-states/screen-sharing-state.d.ts

@@ -0,0 +1,123 @@
+import { AvatarConnectionMachineContext, ScreenShareStreamAcquiredEvent } from '../../types';
+export declare const screenSharingState: {
+    id: string;
+    initial: string;
+    states: {
+        idle: {
+            on: {
+                StartScreenShare: {
+                    target: string;
+                };
+            };
+        };
+        active: {
+            entry: "sendScreenSharePending";
+            initial: string;
+            invoke: {
+                src: "screenCaptureCycle";
+                input: ({ context }: {
+                    context: AvatarConnectionMachineContext;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                    serverUrl: string;
+                };
+            };
+            on: {
+                StopScreenShare: {
+                    target: string;
+                    actions: ("sendScreenShareStopped" | {
+                        type: "setScreenShareActive";
+                        params: {
+                            active: boolean;
+                        };
+                    })[];
+                };
+                ScreenShareEnded: {
+                    target: string;
+                    actions: ("sendScreenShareStopped" | {
+                        type: "setScreenShareActive";
+                        params: {
+                            active: boolean;
+                        };
+                    })[];
+                };
+                ScreenShareError: {
+                    target: string;
+                    actions: ("sendScreenShareStopped" | "showScreenShareErrorNotification" | {
+                        type: "setScreenShareActive";
+                        params: {
+                            active: boolean;
+                        };
+                    })[];
+                };
+            };
+            states: {
+                preparing: {
+                    on: {
+                        ScreenShareStreamAcquired: {
+                            actions: ("sendScreenShareStarted" | {
+                                type: "setScreenShareActive";
+                                params: {
+                                    active: boolean;
+                                    ready?: undefined;
+                                };
+                            } | {
+                                type: "setScreenAnalysisReady";
+                                params: {
+                                    ready: boolean;
+                                    active?: undefined;
+                                };
+                            } | {
+                                type: "setScreenShareStream";
+                                params: ({ event, }: {
+                                    event: ScreenShareStreamAcquiredEvent;
+                                }) => {
+                                    stream: MediaStream;
+                                };
+                            })[];
+                            target: string;
+                        };
+                    };
+                };
+                streaming: {
+                    invoke: {
+                        src: "onScreenAnalysisReady";
+                        input: ({ context, }: {
+                            context: AvatarConnectionMachineContext;
+                        }) => {
+                            logger: import("@unisphere/core").UnisphereLoggerType;
+                        };
+                    };
+                    on: {
+                        ScreenAnalysisReady: {
+                            actions: {
+                                type: "setScreenAnalysisReady";
+                                params: {
+                                    ready: boolean;
+                                };
+                            }[];
+                        };
+                    };
+                    after: {
+                        3000: {
+                            guard: "isAnalysisNotReady";
+                            actions: ({
+                                type: "setScreenAnalysisReady";
+                                params: {
+                                    ready: boolean;
+                                    delayMs?: undefined;
+                                };
+                            } | {
+                                type: "logAnalysisReadyFallback";
+                                params: {
+                                    delayMs: number;
+                                    ready?: undefined;
+                                };
+                            })[];
+                        };
+                    };
+                };
+            };
+        };
+    };
+};

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-states/session-kickoff-state.d.ts

@@ -0,0 +1,61 @@
+import { SessionKickOffRequiredEvent } from '../../types';
+export declare const sessionKickoffState: {
+    id: string;
+    initial: string;
+    states: {
+        unknown: {
+            always: ({
+                guard: "isSessionKickoffRequested";
+                target: string;
+            } | {
+                target: string;
+                guard?: undefined;
+            })[];
+        };
+        enabled: {
+            invoke: {
+                src: "onSessionKickoffEvents";
+                input: ({ context }: {
+                    context: import("../../types").AvatarConnectionMachineContext;
+                    event: import("../../types").AvatarConnectionMachineEvents;
+                    self: import("xstate").ActorRef<import("xstate").MachineSnapshot<import("../../types").AvatarConnectionMachineContext, import("../../types").AvatarConnectionMachineEvents, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, import("../../types").AvatarConnectionMachineEvents, import("xstate").AnyEventObject>;
+                }) => {
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+            }[];
+            on: {
+                SessionKickOffRequired: ({
+                    guard: ({ event }: {
+                        event: SessionKickOffRequiredEvent;
+                    }) => boolean;
+                    actions: {
+                        type: "setSessionKickoffRequired";
+                        params: ({ event }: {
+                            event: SessionKickOffRequiredEvent;
+                        }) => boolean;
+                    };
+                    target: string;
+                } | {
+                    actions: {
+                        type: "setSessionKickoffRequired";
+                        params: ({ event }: {
+                            event: SessionKickOffRequiredEvent;
+                        }) => boolean;
+                    };
+                    guard?: undefined;
+                    target?: undefined;
+                })[];
+                AgentFinishedTalkingReceived: {
+                    guard: "isSessionKickoffActive";
+                    actions: ("raiseAskViaTextKickoff" | {
+                        type: "setSessionKickoffRequired";
+                        params: boolean;
+                    })[];
+                    target: string;
+                };
+            };
+        };
+        finished: {};
+        disabled: {};
+    };
+};