@kaltura-sdk/avatars 1.14.0

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

@@ -0,0 +1,5 @@
+export declare const errorState: {
+    id: string;
+    type: "final";
+    entry: any;
+};

package/src/lib/avatar-client-manager/machines/avatar-connection/states/index.d.ts

@@ -0,0 +1,6 @@
+export * from './connected-state';
+export * from './connecting-state';
+export * from './disconnecting-state';
+export * from './disconnected-state';
+export * from './error-state';
+export * from './preparing-state';

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

@@ -0,0 +1,67 @@
+import { DisconnectReasons } from '@unisphere/genie-types';
+export declare const preparingState: {
+    id: string;
+    initial: string;
+    states: {
+        resolvingConfig: {
+            invoke: {
+                src: "resolveServerConfig";
+                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>;
+                }) => {
+                    runtimeSettings: import("@unisphere/genie-types").AvatarRuntimeSettings;
+                    logger: import("@unisphere/core").UnisphereLoggerType;
+                };
+                onDone: {
+                    target: string;
+                    actions: "setServerConfig";
+                };
+                onError: {
+                    target: string;
+                    actions: "incrementConfigRetry";
+                };
+            };
+        };
+        retryingConfig: {
+            always: ({
+                guard: "hasMoreConfigRetries";
+                target: string;
+                actions?: undefined;
+            } | {
+                actions: {
+                    type: "setDisconnectData";
+                    params: {
+                        reason: DisconnectReasons;
+                        error: Error;
+                    };
+                };
+                target: string;
+                guard?: undefined;
+            })[];
+        };
+        gettingUserAgentData: {
+            invoke: {
+                id: string;
+                src: "getUserAgentData";
+                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;
+                };
+                onDone: {
+                    target: string;
+                    actions: "setUserAgentData";
+                };
+            };
+        };
+        done: {
+            always: {
+                target: string;
+            };
+        };
+    };
+};

package/src/lib/avatar-client-manager/machines/avatar-connection/types/context.d.ts

@@ -0,0 +1,90 @@
+import { UnisphereLoggerType } from '@unisphere/core';
+import { Notifications } from '@unisphere/notifications-core';
+import { clientConfigurationSchema } from './schemas';
+import { z } from 'zod/mini';
+import { KalturaAnalyticsServiceType, PubSubServiceType } from '@unisphere/runtime';
+import { AvatarRuntimeSettings, CaptionConfig, CaptionState, ClientToolCallLogEntry, DisconnectReasons, GenieCapabilities, ChatContext } from '@unisphere/genie-types';
+import { ChatEntry, UnisphereChatBlock } from '@unisphere/genie-types';
+import { AvatarClientToolsRegistry, GetAvatarClientToolHandler } from './input';
+export interface AvatarConnectionMachineContext {
+    logger: UnisphereLoggerType;
+    clientToolsRegistry: AvatarClientToolsRegistry;
+    getClientToolHandler: GetAvatarClientToolHandler;
+    configRetryCount: number;
+    agentRecoveryRetryCount: number;
+    loadingVideoURL: string | null;
+    previewImageUrl: string | null;
+    externalInfo: {
+        runtimeSettings: AvatarRuntimeSettings;
+        stickyId?: string;
+        debugMode: boolean;
+        level: string;
+        waitPlayerReadyState: boolean;
+        kaltura: {
+            ks: string;
+            context?: ChatContext;
+            capabilities?: GenieCapabilities;
+        };
+        threadId?: string;
+        messageId?: string;
+        features?: {
+            screenShare?: boolean;
+            chat?: boolean;
+            captions?: boolean | CaptionConfig;
+            kickOffPhrase?: string;
+        };
+        serverUrl: string;
+        turnServerUrl: string;
+        srsBaseUrl: string;
+        clientId?: string;
+        roomId?: string;
+        flowId?: string;
+        noiseReductionEnabled?: boolean;
+        agentMode?: boolean;
+        isTapToTalk?: boolean;
+    };
+    kalturaContext: {
+        active: boolean;
+    };
+    dynamicVariables?: Record<string, unknown>;
+    /** @deprecated TODO sk consider to avoid saving entire service object inside the machine's context */
+    kalturaAnalyticsService: KalturaAnalyticsServiceType;
+    /** @deprecated TODO sk consider to avoid saving entire service object inside the machine's context */
+    pubSubService: PubSubServiceType;
+    externalActions: {
+        showNotification: (notification: Notifications) => void;
+    };
+    connectionId: string;
+    clientConfiguration: z.infer<typeof clientConfigurationSchema>['clientConfiguration'] | null;
+    peerId: string | null;
+    agentAnswersCount: number;
+    sessionId: string | null;
+    castMode: string | null;
+    webrtcUrl: string | null;
+    threadId: string | null;
+    content: UnisphereChatBlock | null;
+    chatLog: ChatEntry[];
+    clientToolCallLog: ClientToolCallLogEntry[];
+    pendingTextInputs: string[];
+    isAgentTalking: boolean;
+    userAgent: string;
+    userAgentHints: Record<string, string> | null;
+    isMobile: boolean;
+    screenShareActive: boolean;
+    screenShareStream: MediaStream | null;
+    screenAnalysisReady: boolean;
+    sessionKickOffRequired: boolean;
+    isTapToTalkEnabled: boolean;
+    isTapToTalkActive: boolean;
+    tapToTalkStartedAt: number | null;
+    isTapToTalkButtonVisible: boolean;
+    disconnectData: {
+        reason: DisconnectReasons;
+        error?: Error;
+        suppressNotification?: boolean;
+        skipDisconnect?: boolean;
+    } | null;
+    wasUserMutedBeforePause: boolean;
+    wasUserMutedBeforeTapToTalk: boolean;
+    captionState: CaptionState | null;
+}

package/src/lib/avatar-client-manager/machines/avatar-connection/types/events.d.ts

@@ -0,0 +1,274 @@
+import { DoneActorEvent, ErrorActorEvent } from 'xstate';
+import { ChatEntry, UnisphereChatBlock } from '@unisphere/genie-types';
+import { askPermissionsSchema, clientConfigurationSchema, conversationEndedSchema, conversationTimeWarningSchema, joinCompleteSchema, noAgentSchema, onServerConnectedSchema, showAgentSchema, showStartSpeechSchema, stvFinishedTalkingSchema, stvNewSessionSchema, stvStartedTalkingSchema } from './schemas';
+import z from 'zod';
+import { CaptionState, ClientToolCallLogEntry, DisconnectReasons } from '@unisphere/genie-types';
+export declare enum AvatarConnectionMachineEventTypes {
+    Disconnect = "Disconnect",
+    WebsocketReconnected = "WebsocketReconnected",
+    WebsocketConnectionClosed = "WebsocketConnectionClosed",
+    ServerConnectedReceived = "ServerConnectedReceived",
+    ClientConfigurationReceived = "ClientConfigurationReceived",
+    JoinCompleteReceived = "JoinCompleteReceived",
+    SessionCreatedReceived = "SessionCreatedReceived",
+    ShowAgentReceived = "ShowAgentReceived",
+    NoAgentReceived = "NoAgentReceived",
+    ServerReadyReceived = "ServerReadyReceived",
+    ConversationEndedReceived = "ConversationEndedReceived",
+    PlayerReady = "PlayerReady",
+    SetContent = "SetContent",
+    AskViaText = "AskViaText",
+    AgentStartedTalkingReceived = "AgentStartedTalkingReceived",
+    AgentFinishedTalkingReceived = "AgentFinishedTalkingReceived",
+    ConversationTimeWarningReceived = "ConversationTimeWarningReceived",
+    AgentThreadIdReceived = "AgentThreadIdReceived",
+    AgentRawTextMessageCompleted = "AgentRawTextMessageCompleted",
+    AgentClientToolCallCompleted = "AgentClientToolCallCompleted",
+    AgentClientToolCallLogged = "AgentClientToolCallLogged",
+    AgentRecoveryTurnCompleted = "AgentRecoveryTurnCompleted",
+    RequestAgentTurnRecovery = "RequestAgentTurnRecovery",
+    AgentStartSpeechReceived = "AgentStartSpeechReceived",
+    AvatarChatEntryReceived = "AvatarChatEntryReceived",
+    UserVoiceTurnReceived = "UserVoiceTurnReceived",
+    StartScreenShare = "StartScreenShare",
+    StopScreenShare = "StopScreenShare",
+    ScreenShareEnded = "ScreenShareEnded",
+    ScreenShareError = "ScreenShareError",
+    ScreenShareStreamAcquired = "ScreenShareStreamAcquired",
+    ScreenAnalysisReady = "ScreenAnalysisReady",
+    ConversationResumedReceived = "ConversationResumedReceived",
+    PauseExpiryWarningReceived = "PauseExpiryWarningReceived",
+    PauseSessionExpiredReceived = "PauseSessionExpiredReceived",
+    SessionReadyForResumeReceived = "SessionReadyForResumeReceived",
+    ResumingSessionReceived = "ResumingSessionReceived",
+    RequestAvatarPause = "RequestAvatarPause",
+    RequestAvatarResume = "RequestAvatarResume",
+    RequestAvatarPauseAfterSpeaking = "RequestAvatarPauseAfterSpeaking",
+    CaptionStateUpdated = "CaptionStateUpdated",
+    CaptionReplacementsUpdated = "CaptionReplacementsUpdated",
+    CaptionFilterUpdated = "CaptionFilterUpdated",
+    ToggleCaptions = "ToggleCaptions",
+    SessionKickOffRequired = "SessionKickOffRequired",
+    SetDynamicVariables = "SetDynamicVariables",
+    SetKalturaContextActive = "SetKalturaContextActive",
+    RequestTapToTalkStart = "RequestTapToTalkStart",
+    RequestTapToTalkEnd = "RequestTapToTalkEnd",
+    TapToTalkButtonShown = "TapToTalkButtonShown",
+    TapToTalkButtonHidden = "TapToTalkButtonHidden",
+    ToggleTapToTalkMode = "ToggleTapToTalkMode"
+}
+export type WebsocketConnectionClosedEvent = {
+    type: AvatarConnectionMachineEventTypes.WebsocketConnectionClosed;
+    code: number;
+    reason: string;
+};
+export type ServerConnectedReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.ServerConnectedReceived;
+    payload: z.infer<typeof onServerConnectedSchema>;
+};
+export type ClientConfigurationReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.ClientConfigurationReceived;
+    payload: z.infer<typeof clientConfigurationSchema>;
+};
+export type JoinCompleteReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.JoinCompleteReceived;
+    payload: z.infer<typeof joinCompleteSchema>;
+};
+export type SessionCreatedReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.SessionCreatedReceived;
+    payload: z.infer<typeof stvNewSessionSchema>;
+};
+export type ShowAgentReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.ShowAgentReceived;
+    payload: z.infer<typeof showAgentSchema>;
+};
+export type NoAgentReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.NoAgentReceived;
+    payload: z.infer<typeof noAgentSchema>;
+};
+export type DisconnectEvent = {
+    type: AvatarConnectionMachineEventTypes.Disconnect;
+    payload?: {
+        reason: DisconnectReasons;
+        error?: Error;
+        suppressNotification?: boolean;
+    };
+};
+export type ServerReadyReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.ServerReadyReceived;
+    payload: z.infer<typeof askPermissionsSchema>;
+};
+export type ConversationEndedReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.ConversationEndedReceived;
+    payload: z.infer<typeof conversationEndedSchema>;
+};
+export type PlayerReadyEvent = {
+    type: AvatarConnectionMachineEventTypes.PlayerReady;
+};
+export type SetContentEvent = {
+    type: AvatarConnectionMachineEventTypes.SetContent;
+    payload: UnisphereChatBlock | null;
+};
+export type AskViaTextEvent = {
+    type: AvatarConnectionMachineEventTypes.AskViaText;
+    text: string;
+    internal?: boolean;
+};
+export type AgentStartedTalkingReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.AgentStartedTalkingReceived;
+    payload: z.infer<typeof stvStartedTalkingSchema>;
+};
+export type AgentFinishedTalkingReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.AgentFinishedTalkingReceived;
+    payload: z.infer<typeof stvFinishedTalkingSchema>;
+};
+export type ConversationTimeWarningReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.ConversationTimeWarningReceived;
+    payload: z.infer<typeof conversationTimeWarningSchema>;
+};
+export type AgentThreadIdReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.AgentThreadIdReceived;
+    payload: string;
+};
+export type AgentRawTextMessageCompletedEvent = {
+    type: AvatarConnectionMachineEventTypes.AgentRawTextMessageCompleted;
+    messageId: string;
+    speechId: string;
+    blocks: UnisphereChatBlock[];
+};
+export type AgentRecoveryTurnCompletedEvent = {
+    type: AvatarConnectionMachineEventTypes.AgentRecoveryTurnCompleted;
+    hadAvatarType: boolean;
+    speechId: string;
+    messageId: string;
+};
+export type RequestAgentTurnRecoveryEvent = {
+    type: AvatarConnectionMachineEventTypes.RequestAgentTurnRecovery;
+    speechId: string;
+    messageId: string;
+};
+export type AgentClientToolCallCompletedEvent = {
+    type: AvatarConnectionMachineEventTypes.AgentClientToolCallCompleted;
+    toolName: string;
+    waitForResponse: boolean;
+    threadId: string | null;
+};
+export type AgentClientToolCallLoggedEvent = {
+    type: AvatarConnectionMachineEventTypes.AgentClientToolCallLogged;
+    entry: ClientToolCallLogEntry;
+};
+export type AgentStartSpeechReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.AgentStartSpeechReceived;
+    payload: z.infer<typeof showStartSpeechSchema>;
+};
+export type AvatarChatEntryReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.AvatarChatEntryReceived;
+    entry: ChatEntry;
+};
+export type UserVoiceTurnReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.UserVoiceTurnReceived;
+    entry: ChatEntry;
+};
+export type StartScreenShareEvent = {
+    type: AvatarConnectionMachineEventTypes.StartScreenShare;
+};
+export type StopScreenShareEvent = {
+    type: AvatarConnectionMachineEventTypes.StopScreenShare;
+};
+export type ScreenShareEndedEvent = {
+    type: AvatarConnectionMachineEventTypes.ScreenShareEnded;
+};
+export type ScreenAnalysisReadyEvent = {
+    type: AvatarConnectionMachineEventTypes.ScreenAnalysisReady;
+};
+export type ScreenShareErrorEvent = {
+    type: AvatarConnectionMachineEventTypes.ScreenShareError;
+    error?: Error;
+};
+export type ScreenShareStreamAcquiredEvent = {
+    type: AvatarConnectionMachineEventTypes.ScreenShareStreamAcquired;
+    stream: MediaStream;
+};
+export type WebSocketReconnectedEvent = {
+    type: AvatarConnectionMachineEventTypes.WebsocketReconnected;
+    newSocketId: string;
+};
+export type SessionKickOffRequiredEvent = {
+    type: AvatarConnectionMachineEventTypes.SessionKickOffRequired;
+    value: boolean;
+};
+export type SetKalturaContextActiveEvent = {
+    type: AvatarConnectionMachineEventTypes.SetKalturaContextActive;
+    active: boolean;
+};
+export type SetDynamicVariablesEvent = {
+    type: AvatarConnectionMachineEventTypes.SetDynamicVariables;
+    data: Record<string, unknown> | undefined;
+};
+export type RequestTapToTalkStartEvent = {
+    type: AvatarConnectionMachineEventTypes.RequestTapToTalkStart;
+};
+export type RequestTapToTalkEndEvent = {
+    type: AvatarConnectionMachineEventTypes.RequestTapToTalkEnd;
+};
+export type TapToTalkButtonShownEvent = {
+    type: AvatarConnectionMachineEventTypes.TapToTalkButtonShown;
+};
+export type TapToTalkButtonHiddenEvent = {
+    type: AvatarConnectionMachineEventTypes.TapToTalkButtonHidden;
+};
+export type WebsocketConnectedEvent = DoneActorEvent<string, 'connectWebSocket'>;
+export type WebsocketConnectionErrorEvent = ErrorActorEvent<Error, 'connectWebSocket'>;
+export type UserMediaReceivedEvent = DoneActorEvent<MediaStream, 'initUserMedia'>;
+export type UserMediaErrorEvent = ErrorActorEvent<Error, 'initUserMedia'>;
+export type ConnectionDestroyedEvent = DoneActorEvent<void, 'destroyConnection'>;
+export type ConnectionDestroyErrorEvent = ErrorActorEvent<Error, 'destroyConnection'>;
+export type GetUserAgentDataReceivedEvent = DoneActorEvent<{
+    userAgent: string;
+    userAgentHints: Record<string, string>;
+}, 'getUserAgentData'>;
+export type ConversationResumedReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.ConversationResumedReceived;
+};
+export type PauseExpiryWarningReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.PauseExpiryWarningReceived;
+    secondsRemaining: number;
+};
+export type PauseSessionExpiredReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.PauseSessionExpiredReceived;
+};
+export type SessionReadyForResumeReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.SessionReadyForResumeReceived;
+};
+export type ResumingSessionReceivedEvent = {
+    type: AvatarConnectionMachineEventTypes.ResumingSessionReceived;
+};
+export type RequestAvatarPauseEvent = {
+    type: AvatarConnectionMachineEventTypes.RequestAvatarPause;
+};
+export type RequestAvatarResumeEvent = {
+    type: AvatarConnectionMachineEventTypes.RequestAvatarResume;
+};
+export type RequestAvatarPauseAfterSpeakingEvent = {
+    type: AvatarConnectionMachineEventTypes.RequestAvatarPauseAfterSpeaking;
+};
+export type CaptionStateUpdatedEvent = {
+    type: AvatarConnectionMachineEventTypes.CaptionStateUpdated;
+    payload: CaptionState;
+};
+export type CaptionReplacementsUpdatedEvent = {
+    type: AvatarConnectionMachineEventTypes.CaptionReplacementsUpdated;
+    replacements: Record<string, string> | null;
+};
+export type CaptionFilterUpdatedEvent = {
+    type: AvatarConnectionMachineEventTypes.CaptionFilterUpdated;
+    filter: ((text: string) => string) | null;
+};
+export type ToggleCaptionsEvent = {
+    type: AvatarConnectionMachineEventTypes.ToggleCaptions;
+};
+export type ToggleTapToTalkModeEvent = {
+    type: AvatarConnectionMachineEventTypes.ToggleTapToTalkMode;
+    enabled: boolean;
+};
+export type AvatarConnectionMachineEvents = WebSocketReconnectedEvent | WebsocketConnectionClosedEvent | WebsocketConnectionErrorEvent | WebsocketConnectedEvent | ServerConnectedReceivedEvent | ClientConfigurationReceivedEvent | JoinCompleteReceivedEvent | SessionCreatedReceivedEvent | ShowAgentReceivedEvent | NoAgentReceivedEvent | ConversationEndedReceivedEvent | DisconnectEvent | ServerReadyReceivedEvent | UserMediaReceivedEvent | UserMediaErrorEvent | ConnectionDestroyedEvent | ConnectionDestroyErrorEvent | PlayerReadyEvent | SetContentEvent | AskViaTextEvent | AgentStartedTalkingReceivedEvent | AgentFinishedTalkingReceivedEvent | ConversationTimeWarningReceivedEvent | AgentThreadIdReceivedEvent | AgentRawTextMessageCompletedEvent | AgentClientToolCallCompletedEvent | AgentClientToolCallLoggedEvent | AgentRecoveryTurnCompletedEvent | RequestAgentTurnRecoveryEvent | GetUserAgentDataReceivedEvent | AgentStartSpeechReceivedEvent | AvatarChatEntryReceivedEvent | UserVoiceTurnReceivedEvent | StartScreenShareEvent | StopScreenShareEvent | ScreenShareEndedEvent | ScreenShareErrorEvent | ScreenShareStreamAcquiredEvent | ScreenAnalysisReadyEvent | ConversationResumedReceivedEvent | PauseExpiryWarningReceivedEvent | PauseSessionExpiredReceivedEvent | SessionReadyForResumeReceivedEvent | ResumingSessionReceivedEvent | RequestAvatarPauseEvent | RequestAvatarResumeEvent | RequestAvatarPauseAfterSpeakingEvent | CaptionStateUpdatedEvent | CaptionReplacementsUpdatedEvent | CaptionFilterUpdatedEvent | ToggleCaptionsEvent | SessionKickOffRequiredEvent | SetDynamicVariablesEvent | SetKalturaContextActiveEvent | RequestTapToTalkStartEvent | RequestTapToTalkEndEvent | TapToTalkButtonShownEvent | TapToTalkButtonHiddenEvent | ToggleTapToTalkModeEvent;

package/src/lib/avatar-client-manager/machines/avatar-connection/types/index.d.ts

@@ -0,0 +1,26 @@
+import type { ActionFunction, ActorRefFrom, SnapshotFrom, StatesConfig } from 'xstate';
+import { AvatarConnectionMachineContext } from './context';
+import { AvatarConnectionMachineEvents } from './events';
+import { avatarConnectionMachine } from '../avatar-connection-machine';
+export * from './events';
+export * from './context';
+export * from './input';
+export * from './schemas';
+export declare const AvatarConnectionMachineId = "AvatarClient";
+export type AvatarConnectionActor = ActorRefFrom<typeof avatarConnectionMachine>;
+export type AvatarConnectionMachineState = SnapshotFrom<typeof avatarConnectionMachine>;
+export type AvatarConnectionMachineStateConfig = StatesConfig<AvatarConnectionMachineContext, AvatarConnectionMachineEvents, any, // TActorLogic
+any, // TAction
+any, // TGuard
+never, // TDelay
+never, // TTag
+never, // TOutput
+never, // TEmit,
+never>;
+export type AvatarConnectionMachineAction<TParams = unknown> = ActionFunction<AvatarConnectionMachineContext, AvatarConnectionMachineEvents, any, // TEvent
+TParams, // TParams
+any, // TActor
+never, // TAction
+never, // TGuard
+never, // TDelay
+never>;

package/src/lib/avatar-client-manager/machines/avatar-connection/types/input.d.ts

@@ -0,0 +1,30 @@
+import { UnisphereLoggerType } from '@unisphere/core';
+import { Notifications } from '@unisphere/notifications-core';
+import { KalturaAnalyticsServiceType, PubSubServiceType } from '@unisphere/runtime';
+import { AvatarRuntimeSettings } from '@unisphere/genie-types';
+import type { ClientToolHandler, ClientToolsInput, ClientToolsRegistry, GetClientToolHandler } from '@local/genie-shared-utils';
+export type AvatarClientToolHandler = ClientToolHandler;
+export type AvatarClientToolsRegistry = ClientToolsRegistry;
+export type AvatarClientToolsInput<TMap extends Record<string, unknown> = Record<string, unknown>> = ClientToolsInput<TMap>;
+export type GetAvatarClientToolHandler = GetClientToolHandler;
+export interface AvatarConnectionMachineInput {
+    connectionId: string;
+    logger: UnisphereLoggerType;
+    debugMode: boolean;
+    kalturaAnalyticsService: KalturaAnalyticsServiceType;
+    pubSubService: PubSubServiceType;
+    externalActions: {
+        showNotification: (notification: Notifications) => void;
+    };
+    runtimeSettings: AvatarRuntimeSettings;
+    stickyId?: string;
+    level?: string;
+    waitPlayerReadyState?: boolean;
+    isInitialKalturaContextActive?: boolean;
+    threadId?: string;
+    messageId?: string;
+    dynamicVariables?: Record<string, unknown>;
+    kickOffPhrase?: string;
+    clientToolsRegistry: AvatarClientToolsRegistry;
+    getClientToolHandler: GetAvatarClientToolHandler;
+}

package/src/lib/avatar-client-manager/machines/avatar-connection/types/notifications.d.ts

@@ -0,0 +1,4 @@
+import { Notifications } from '@unisphere/notifications-core';
+import { DisconnectReasons } from '@unisphere/genie-types';
+export declare function isMappedAvatarDisconnectReason(reason: DisconnectReasons): boolean;
+export declare function getAvatarConnectionNotification(reason: DisconnectReasons): Notifications;

package/src/lib/avatar-client-manager/machines/avatar-connection/types/schemas.d.ts

@@ -0,0 +1,105 @@
+import { z } from 'zod/mini';
+export declare const onServerConnectedSchema: z.ZodMiniObject<{
+    finalUrl: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniLiteral<"">]>;
+    loadingVideoURL: z.ZodMiniOptional<z.ZodMiniURL>;
+    agentName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    hostName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export declare const clientConfigurationSchema: z.ZodMiniObject<{
+    clientConfiguration: z.ZodMiniObject<{
+        configuration: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
+        nluFeatures: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
+        languageCode: z.ZodMiniString<string>;
+        isTapToTalk: z.ZodMiniBoolean<boolean>;
+        isWebSearchEnabled: z.ZodMiniBoolean<boolean>;
+        isScreenShareEnabled: z.ZodMiniBoolean<boolean>;
+        isCameraAnalysisEnabled: z.ZodMiniBoolean<boolean>;
+        youtubeUrl: z.ZodMiniString<string>;
+        audioMode: z.ZodMiniBoolean<boolean>;
+        phoneMode: z.ZodMiniBoolean<boolean>;
+        initialHtml: z.ZodMiniString<string>;
+        visualPhotos: z.ZodMiniArray<z.ZodMiniUnknown>;
+        visualVideos: z.ZodMiniArray<z.ZodMiniUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const joinCompleteSchema: z.ZodMiniObject<{}, z.core.$strip>;
+export declare const stvNewSessionSchema: z.ZodMiniObject<{
+    session_id: z.ZodMiniString<string>;
+    status: z.ZodMiniString<string>;
+    webrtc_url: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    cast_mode: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export declare const showAgentSchema: z.ZodMiniObject<{}, z.core.$strip>;
+export declare const noAgentSchema: z.ZodMiniObject<{}, z.core.$strip>;
+export declare const askPermissionsSchema: z.ZodMiniObject<{
+    constraints: z.ZodMiniObject<{
+        audio: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniObject<{
+            echoCancellation: z.ZodMiniBoolean<boolean>;
+        }, z.core.$strip>]>;
+        video: z.ZodMiniBoolean<boolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const conversationEndedSchema: z.ZodMiniObject<{}, z.core.$strip>;
+export declare const stvStartedTalkingSchema: z.ZodMiniObject<{}, z.core.$strip>;
+export declare const stvFinishedTalkingSchema: z.ZodMiniObject<{
+    agentContent: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export declare const conversationTimeWarningSchema: z.ZodMiniObject<{
+    remainingTime: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export declare const pauseExpiryWarningSchema: z.ZodMiniObject<{
+    secondsRemaining: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+export declare const generatingSpeechSchema: z.ZodMiniObject<{
+    text: z.ZodMiniString<string>;
+    speechId: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export declare const agentTurnToTalkSchema: z.ZodMiniObject<{
+    userTranscription: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    turnId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export declare const agentRawTextSchema: z.ZodMiniObject<{
+    speechId: z.ZodMiniString<string>;
+    turnId: z.ZodMiniString<string>;
+    delta: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export declare const agentRawTextDeltaSchema: z.ZodMiniObject<{
+    messageId: z.ZodMiniString<string>;
+    threadId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    role: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    type: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    content: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>]>>;
+    segmentNumber: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    et: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    segmentStart: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    segmentEnd: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    metadata: z.ZodMiniOptional<z.ZodMiniObject<{
+        widgetName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        runtimeName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>>;
+    event: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    status: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    openingPhrase: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export declare const agentRawTextClientToolDeltaSchema: z.ZodMiniObject<{
+    messageId: z.ZodMiniString<string>;
+    threadId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    role: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    content: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>]>>;
+    segmentNumber: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    et: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    segmentStart: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    segmentEnd: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    type: z.ZodMiniLiteral<"tool">;
+    tool_metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
+}, z.core.$strip>;
+export declare const showStartSpeechSchema: z.ZodMiniObject<{
+    speechId: z.ZodMiniString<string>;
+    isNewTurn: z.ZodMiniBoolean<boolean>;
+    turnId: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export declare const stvSpeechChunkSchema: z.ZodMiniObject<{
+    text: z.ZodMiniString<string>;
+    durationMs: z.ZodMiniNumber<number>;
+    speechId: z.ZodMiniString<string>;
+}, z.core.$strip>;

package/src/lib/avatar-client-manager/machines/avatar-connection/utils/agent-raw-text-blocks-creator.d.ts

@@ -0,0 +1,32 @@
+import { UnisphereChatBlock } from '@unisphere/genie-types';
+import { UnisphereLoggerType } from '@unisphere/core';
+export interface ResponseDataType {
+    threadId?: string;
+    messageId?: string;
+    type?: string;
+    content: string;
+    metadata?: {
+        widgetName?: string;
+        runtimeName?: string;
+    } | null;
+    segmentNumber?: number;
+    segmentStart?: boolean;
+    segmentEnd?: boolean;
+}
+export declare const isResponseDataType: (item: unknown) => item is ResponseDataType;
+export declare class ChatBlocksCreator {
+    private logger;
+    private _streamedToolBlockData;
+    constructor(logger: UnisphereLoggerType);
+    handleChunk(item: ResponseDataType, isSharedMessage?: boolean): UnisphereChatBlock[];
+    private _buildTextBlock;
+    private _createSharedToolBlock;
+    private _handleToolChunk;
+    private _initToolBlock;
+    private _updateToolBlock;
+    private _buildToolBlock;
+    private _maybeHandleBrokenToolEnd;
+    private _resetCurrentBlock;
+    private _generateBlockId;
+    private _hasRequiredMetadata;
+}

package/src/lib/avatar-client-manager/machines/avatar-connection/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './resolve-capabilities';
+export * from './agent-raw-text-blocks-creator';

package/src/lib/avatar-client-manager/machines/avatar-connection/utils/resolve-active-kaltura-context.d.ts

@@ -0,0 +1,2 @@
+import { AvatarConnectionMachineContext } from '../types';
+export declare const resolveActiveKalturaContext: (context: AvatarConnectionMachineContext) => import("dist/unisphere/packages/unisphere/types/src").ChatContext | undefined;

package/src/lib/avatar-client-manager/machines/avatar-connection/utils/resolve-capabilities.d.ts

@@ -0,0 +1,10 @@
+import { AvatarConnectionMachineContext } from '../types';
+export declare const resolveCapabilities: (context: AvatarConnectionMachineContext) => {
+    use_knowledge_base?: string | undefined;
+    use_content_search?: import("@unisphere/genie-types").CapabilityToggle | undefined;
+    use_get_entry_content?: import("@unisphere/genie-types").CapabilityToggle | undefined;
+    generate_followup_questions?: import("@unisphere/genie-types").CapabilityToggle | undefined;
+    include_sources?: import("@unisphere/genie-types").CapabilityToggle | undefined;
+    use_related_files?: import("@unisphere/genie-types").CapabilityToggle | undefined;
+    avatar?: import("@unisphere/genie-types").CapabilityToggle | undefined;
+};