@alxxsck/ai-assistant 1.0.0

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SM_BREAKPOINT = 640;
+export declare const SHOW_REACTION_MESSAGE_DURATION = 5000;

package/dist/context/ChatWidgetContext.d.ts

@@ -0,0 +1,32 @@
+import type { AppApi } from "@/App";
+import type { Avatar } from "@/avatar/Avatar";
+import type { WidgetConfig } from "@/index.types";
+import type { CtaCommandContext } from "@/domain/command/command.types";
+type ChatWidgetContextValue = {
+    open: boolean;
+    setOpen: (v: boolean) => void;
+    /** False when `manualOpen` is false and the widget was dismissed; chrome stays mounted but is hidden and non-interactive until `setOpen(true)`. */
+    isChromeVisible: boolean;
+    widgetHeight: number;
+    setWidgetHeight: (h: number) => void;
+    widgetWidth: number;
+    setWidgetWidth: (w: number) => void;
+    reactionMessage: string | null;
+    setReactionMessage: (message: string | null) => void;
+    isMobile: boolean;
+    config: WidgetConfig;
+    api: AppApi;
+    loadingProgress: number;
+    setLoadingProgress: (p: number) => void;
+    assistantRef: React.RefObject<Avatar | null>;
+    cta: CtaCommandContext | null;
+    executeCta: () => Promise<void>;
+    dismissCta: () => void;
+};
+export declare const ChatWidgetContextProvider: ({ children, config, api, }: {
+    children: React.ReactNode;
+    config: WidgetConfig;
+    api: AppApi;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useChatWidget(): ChatWidgetContextValue;
+export {};

package/dist/domain/command/CommandRuntime.d.ts

@@ -0,0 +1,50 @@
+import type { CustomerInteractionSession } from "@/types";
+import { type CommandAck, type CommandEnvelope, type CommandEventDetail, type CtaCommandContext, type HostCommandHandlerName, type HostCommandHandlers, type UiTarget } from "./command.types";
+type AckSender = (ack: CommandAck) => Promise<unknown>;
+type InternalHandlers = {
+    setAssistantVisible?: (visible: boolean) => void;
+    setChatOpen?: (open: boolean) => void;
+    playAnimation?: (animation: string) => void;
+    showCta?: (context: CtaCommandContext) => void;
+};
+export declare class CommandRuntime {
+    private readonly onStatus?;
+    private readonly targets;
+    private readonly hostHandlers;
+    private readonly internalHandlers;
+    private readonly internalHandlersReady;
+    private resolveInternalHandlers;
+    private readonly completed;
+    private readonly inFlight;
+    private readonly highlights;
+    constructor(targets?: Record<string, UiTarget>, handlers?: HostCommandHandlers, onStatus?: ((detail: CommandEventDetail) => void) | undefined);
+    registerTarget(code: string, target: UiTarget): () => void;
+    registerHostHandler<K extends HostCommandHandlerName>(name: K, handler: NonNullable<HostCommandHandlers[K]>): () => void;
+    setInternalHandlers(handlers: InternalHandlers): () => void;
+    execute(envelope: CommandEnvelope, session: CustomerInteractionSession, sendAck: AckSender): Promise<void>;
+    executeCtaAction(context: CtaCommandContext): Promise<void>;
+    destroy(): void;
+    private executeOnce;
+    private dispatch;
+    private executeTargetCommand;
+    private executeHighlight;
+    private executeShowCta;
+    private canOpenPage;
+    private canOpenModal;
+    private requireTarget;
+    private findTargetElement;
+    private applyDefaultHighlight;
+    private removeDefaultHighlight;
+    private requireInternal;
+    private requireString;
+    private firstDefined;
+    private applyUrlFallback;
+    private targetUrl;
+    private assertTargetCode;
+    private finish;
+    private storageKey;
+    private loadCompleted;
+    private saveCompleted;
+    private toAck;
+}
+export {};

package/dist/domain/command/command.types.d.ts

@@ -0,0 +1,70 @@
+export declare const COMMAND_TYPES: readonly ["show_assistant", "hide_assistant", "open_chat", "close_chat", "play_animation", "highlight_element", "remove_highlight", "show_cta", "open_page", "open_modal"];
+export type CommandType = (typeof COMMAND_TYPES)[number];
+export type CommandAckStatus = "received" | "succeeded" | "failed" | "expired" | "unsupported";
+export type CommandAck = {
+    commandId: string;
+    status: CommandAckStatus;
+    errorCode?: string;
+    details?: Record<string, unknown>;
+};
+export type CommandEnvelope = {
+    type: "command.created";
+    eventId: string;
+    sequence: number;
+    occurredAt: string;
+    data: {
+        commandId: string;
+        scenarioRunId: string;
+        interactionSessionId: string;
+        commandType: string;
+        target?: {
+            id?: string;
+            code?: string;
+        };
+        payload: Record<string, unknown>;
+        expiresAt: string | null;
+    };
+};
+export type UiTargetKind = "button" | "element" | "modal" | "page";
+export type UiTarget = {
+    kind: UiTargetKind;
+    /** Trusted selector supplied by the host application. */
+    selector?: string;
+    /** Trusted route used by the built-in openPage fallback. */
+    route?: string;
+    /** Explicit URL fallback. It may include query parameters such as lola_modal. */
+    url?: string;
+    /** Query parameters merged into url, route, or the current location. Null removes a key. */
+    query?: Record<string, string | null>;
+};
+export type HostCommandContext = {
+    commandId: string;
+    commandType: CommandType;
+    target: string;
+    targetDefinition?: UiTarget;
+    payload: Readonly<Record<string, unknown>>;
+    url?: string;
+    route?: string;
+    modalId?: string;
+    modalCode?: string;
+};
+export type HighlightCommandContext = HostCommandContext & {
+    active: boolean;
+    element?: Element;
+};
+export type CtaCommandContext = Omit<HostCommandContext, "target"> & {
+    label: string;
+    action: "none" | "open_modal" | "open_page";
+    target?: string;
+};
+export type HostCommandHandlers = {
+    openPage?: (context: HostCommandContext) => void | Promise<void>;
+    openModal?: (context: HostCommandContext) => void | Promise<void>;
+    highlight?: (context: HighlightCommandContext) => void | Promise<void>;
+    showCta?: (context: CtaCommandContext) => void | Promise<void>;
+};
+export type HostCommandHandlerName = keyof HostCommandHandlers;
+export type HostCommandHandler = NonNullable<HostCommandHandlers[HostCommandHandlerName]>;
+export type CommandEventDetail = CommandAck & {
+    commandType?: string;
+};

package/dist/domain/message/cable/AnyCable.service.d.ts

@@ -0,0 +1,34 @@
+import type { Channel } from "@anycable/web";
+import { WidgetChatChannel } from "./WidgetChat.channel";
+import type { CommandAck } from "@/domain/command/command.types";
+import type { ScenarioChoiceInput } from "@/domain/scenario/scenario-choice";
+/**
+ * AnyCableService is responsible for managing the WebSocket connection and
+ * subscribing to channels.
+ */
+export declare class AnyCableService {
+    private url;
+    private cable?;
+    channels: {
+        chat: WidgetChatChannel;
+    };
+    constructor(url: string, onMessage?: (message: unknown) => void);
+    /**
+     * Subscribes to a channel
+     *
+     * @param channel - The channel to subscribe to
+     */
+    subscribe(channel: Channel): this;
+    /**
+     * Unsubscribes from a channel
+     *
+     * @param channel - The channel to unsubscribe from
+     */
+    unsubscribe(channel: Channel): this;
+    acknowledgeCommand(ack: CommandAck): Promise<unknown>;
+    submitScenarioChoice(input: ScenarioChoiceInput): Promise<unknown>;
+    /** Registers the cable and subscribes to the bridge channel */
+    private register;
+    /** Unregisters the cable and disconnects from the WebSocket server */
+    unregister(): void;
+}

package/dist/domain/message/cable/CableContext.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from "react";
+import { AnyCableService } from "./AnyCable.service";
+import { NetworkStatus } from "./CableContext.types";
+import type { WidgetConfig } from "@/index.types";
+import type { CommandRuntime } from "@/domain/command/CommandRuntime";
+interface CableContextType {
+    anycableService: AnyCableService | null;
+    networkStatus: NetworkStatus;
+}
+interface CableProviderProps {
+    children: ReactNode;
+    config: WidgetConfig;
+    commandRuntime: CommandRuntime;
+}
+export declare const CableProvider: ({ children, config, commandRuntime, }: CableProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useCable: () => CableContextType;
+export {};

package/dist/domain/message/cable/CableContext.types.d.ts

@@ -0,0 +1,19 @@
+export declare enum NetworkStatus {
+    /** When we are trying to establish WS connection */
+    Pending = "pending",
+    /**
+     * When the user is online (has access to the internet) and WS connection is
+     * established
+     */
+    Available = "available",
+    /**
+     * When the user is offline (no internet access) but WS connection is
+     * established
+     */
+    Offline = "offline",
+    /**
+     * When the user is offline (no internet access) and WS connection is not
+     * established
+     */
+    Unavailable = "unavailable"
+}

package/dist/domain/message/cable/WidgetChat.channel.d.ts

@@ -0,0 +1,4 @@
+import { Channel } from "@anycable/web";
+export declare class WidgetChatChannel extends Channel {
+    static identifier: string;
+}

package/dist/domain/message/cable/widget-message.d.ts

@@ -0,0 +1,3 @@
+import type { AgenticStepsAppendedData, MessageData } from "@/api/messages.api.types";
+export declare const getMessageFromFrame: (frame: unknown) => MessageData | null;
+export declare const getAgenticStepsFromFrame: (frame: unknown) => AgenticStepsAppendedData | null;

package/dist/domain/message/message.store.d.ts

@@ -0,0 +1,51 @@
+import { type AgenticStepsAppendedData, type ConversationData, type MessageData } from "@/api/messages.api.types";
+import type { AppApi } from "@/App";
+import type { WidgetConfig } from "@/index.types";
+export interface ThreadSummary {
+    threadId: string;
+    lastMessage: MessageData;
+}
+export type MessageStore = {
+    currentThreadId: string | undefined;
+    currentThreadMessages: MessageData[];
+    messages: MessageData[];
+    conversations: ConversationData[];
+    threadIds: string[];
+    threads: Map<string, MessageData[]>;
+    threadsPreviews: ThreadSummary[];
+    sendError: string | null;
+    config: WidgetConfig | null;
+    api: AppApi | null;
+    latestReadMessageDate: string | null;
+    latestMessageDate: string | null;
+    actions: MessageStoreActions;
+};
+type MessageStoreActions = {
+    initMessageStore: (config: WidgetConfig, api: AppApi) => Promise<void>;
+    setCurrentThread: (conversationId: string) => Promise<void>;
+    createNewConversation: () => Promise<string>;
+    handleMessage: (message: MessageData) => void;
+    sendMessage: (message: string) => Promise<void>;
+    clearSendError: () => void;
+    getThreadsSummaryData: () => ThreadSummary[];
+    setLatestReadMessageDate: (readMessageDate: string) => void;
+    addMessage: (message: MessageData) => void;
+    updateMessage: (message: MessageData, index: number) => void;
+    handleMessagesAgenticSteps: (message: AgenticStepsAppendedData) => void;
+    updateThreads: () => void;
+    fetchThreadMessages: (conversationId: string) => Promise<void>;
+    setCurrentThreadMessages: (conversationId: string) => void;
+    sendServiceMessage: (message: string) => Promise<void>;
+    updateConfig: (config: WidgetConfig, api: AppApi) => void;
+    recoverMessages: () => Promise<void>;
+};
+export declare const useMessageStore: import("zustand").UseBoundStore<import("zustand").StoreApi<MessageStore>>;
+export declare const useSelectCurrentThreadId: () => string | undefined;
+export declare const useSelectCurrentThreadMessages: () => MessageData[];
+export declare const useSelectThreadsPreviews: () => ThreadSummary[];
+export declare const useCurrentThreadId: () => string | undefined;
+export declare const useLatestReadMessageDate: () => string | null;
+export declare const useLatestMessageDate: () => string | null;
+export declare const useSendError: () => string | null;
+export declare const useMessageStoreActions: () => MessageStoreActions;
+export {};

package/dist/domain/scenario/scenario-choice.d.ts

@@ -0,0 +1,17 @@
+import type { MessageData } from "@/api/messages.api.types";
+export type ScenarioChoiceOption = {
+    id: string;
+    label: string;
+};
+export type ScenarioChoiceCommand = {
+    type: "ask_choice";
+    inputRequestId: string;
+    options: ScenarioChoiceOption[];
+};
+export type ScenarioChoiceInput = {
+    inputRequestId: string;
+    optionId: string;
+    clientEventId: string;
+};
+export declare const getScenarioChoice: (message: MessageData) => ScenarioChoiceCommand | null;
+export declare const getLatestScenarioChoice: (messages: MessageData[]) => ScenarioChoiceCommand | null;

package/dist/domain/ui/ui.service.d.ts

@@ -0,0 +1,7 @@
+type WidgetUIData = {
+    width: number;
+    height: number;
+};
+export declare function loadWidgetUIData(): WidgetUIData | null;
+export declare function saveWidgetUIData(data: WidgetUIData): void;
+export {};

package/dist/domain/voice/voice.store.d.ts

@@ -0,0 +1,69 @@
+import type { AppApi } from "@/App";
+import type { VoiceSessionData } from "@/api/voice.api.types";
+import type { WidgetConfig } from "@/index.types";
+/** Arguments for creating a local media stream */
+export interface GetLocalStreamArgs {
+    /** Optional audio input device ID */
+    inputAudioDeviceId?: string;
+}
+type VoiceStatus = "idle" | "connecting" | "live" | "ending" | "error";
+type VoiceStore = {
+    activeVoiceSessionData: VoiceSessionData | null;
+    config: WidgetConfig | null;
+    api: AppApi | null;
+    status: VoiceStatus;
+    errorMessage: string | null;
+    isVoiceBootstrapped: boolean;
+    connection: RTCPeerConnection | null;
+    connectionId: string | null;
+    connectionGeneration: number | null;
+    iceCandidates: RTCIceCandidateInit[];
+    voiceEventsChannel: RTCDataChannel | null;
+    voiceInputChannel: RTCDataChannel | null;
+    downstream: MediaStream | null;
+    localStream: MediaStream | null;
+    remoteAudioElement: HTMLAudioElement | null;
+    customerMessageTranscript: string;
+    customerMessageTranscriptVisible: boolean;
+    assistantMessageTranscript: string;
+    assistantMessageTranscriptVisible: boolean;
+    assistantResponseInProgress: boolean;
+    microphoneEnabled: boolean;
+    inputAudioDevice: MediaDeviceInfo | null;
+    audioInputDevices: MediaDeviceInfo[];
+    actions: VoiceStoreActions;
+};
+type VoiceStoreActions = {
+    onVoiceEventsEvent: (event: MessageEvent<string>) => void;
+    onVoiceInputEvent: (event: MessageEvent<string>) => void;
+    initVoiceStore: (config: WidgetConfig, api: AppApi) => Promise<void>;
+    createConnection: () => RTCPeerConnection;
+    sendCandidates: () => Promise<void>;
+    playRemoteAudio: (stream: MediaStream) => void;
+    endVoiceSession: (reason?: string) => Promise<void>;
+    setMicrophoneEnabled: (enabled: boolean) => void;
+    sendOffer: (offer: RTCSessionDescriptionInit) => Promise<void>;
+    getLocalStream: (deviceId?: string) => Promise<MediaStream | null>;
+    setNewLocalStream: () => Promise<void>;
+    createAudioTrack: () => Promise<MediaStreamTrack | null>;
+    attachAudioTrack: (newTrack: MediaStreamTrack, { replaceExisting }: {
+        replaceExisting: boolean;
+    }) => Promise<MediaStreamTrack>;
+    ensureAudioTrack: () => Promise<boolean>;
+    recreateAudioTrack: () => Promise<boolean>;
+    enableMicrophone: () => Promise<void>;
+    disableMicrophone: () => void;
+    switchAudio: () => Promise<void>;
+    refreshAudioProcessing: () => Promise<void>;
+    switchInputAudioDevice: (newDevice: MediaDeviceInfo) => Promise<void>;
+};
+export declare const useVoiceStore: import("zustand").UseBoundStore<import("zustand").StoreApi<VoiceStore>>;
+export declare const useVoiceStoreActions: () => VoiceStoreActions;
+export declare const useMicrophoneEnabled: () => boolean;
+export declare const useInputAudioDevice: () => MediaDeviceInfo | null;
+export declare const useLocalStream: () => MediaStream | null;
+export declare const useConnection: () => RTCPeerConnection | null;
+export declare const useConnectionId: () => string | null;
+export declare const useDownstream: () => MediaStream | null;
+export declare const useCustomerMessageTranscript: () => string;
+export {};

package/dist/hooks/useDeviceManager.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Hook for managing media devices (audio input, audio output, video input) in
+ * video calls.
+ *
+ * This hook provides:
+ *
+ * - Automatic device enumeration and updates
+ * - Device change event listening
+ * - Automatic fallback to available devices when current device is disconnected
+ * - Permission handling for device access
+ *
+ * The hook automatically:
+ *
+ * - Enumerates available devices on mount
+ * - Listens for device changes (connect/disconnect)
+ * - Switches to the first available device if the current device becomes
+ *   unavailable
+ * - Requests microphone permission if needed to get device labels
+ *
+ * @returns Void - This hook doesn't return any values, it manages device state
+ *   internally
+ */
+export declare const useDeviceManager: () => {
+    updateDevices: (e?: Event) => Promise<void>;
+};

package/dist/hooks/useSessionExpiryChecks.d.ts

@@ -0,0 +1,3 @@
+import type { AppApi } from "@/App";
+import type { WidgetConfig } from "@/index.types";
+export declare function useSessionExpiryChecks(config: WidgetConfig, api: AppApi, open: boolean): void;

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import type { ExternallyAvailableActions } from "./avatar/Avatar";
+import type { WidgetConfig } from "./index.types";
+import type { CustomerInteractionSession } from "./types";
+import type { HostCommandHandlerName, UiTarget } from "./domain/command/command.types";
+export type { WidgetConfig } from "./index.types";
+export declare const ASSETS_URL = "https://metamediastatic.com";
+export declare class ChatWidgetInstance extends EventTarget {
+    private root;
+    private shadowRoot;
+    private config;
+    private gui;
+    private setOpenImpl;
+    private sendServiceMessageImpl;
+    private playAnimationImpl;
+    private executeReactionImpl;
+    private resolveAssetPath;
+    private setLocaleImpl;
+    private setSessionImpl;
+    private readonly commandRuntime;
+    constructor(config: WidgetConfig);
+    private initGui;
+    private init;
+    private fetchAndMergeRemoteConfig;
+    private onAvatarReady;
+    private onSessionExpired;
+    private onCommandStatus;
+    private injectStyles;
+    setOpen(open: boolean): void;
+    playAnimation(name: ExternallyAvailableActions): void;
+    setCustomerInteractionSession(session: CustomerInteractionSession): void;
+    registerUiTarget(code: string, target: UiTarget): () => void;
+    registerCommandHandler<K extends HostCommandHandlerName>(name: K, handler: NonNullable<NonNullable<WidgetConfig["commandHandlers"]>[K]>): () => void;
+    executeReaction(params: {
+        animation: string;
+        voice: string;
+        text: string;
+    }): void;
+    sendServiceMessage(message: string, animationName: ExternallyAvailableActions): void;
+    setLocale(locale: string): void;
+    destroy(): void;
+}

package/dist/index.types.d.ts

@@ -0,0 +1,50 @@
+import type { ExternallyAvailableActions } from "./avatar/Avatar";
+import type { CustomerInteractionSession } from "./types";
+import type { CommandEventDetail, HostCommandHandlerName, HostCommandHandlers, UiTarget } from "./domain/command/command.types";
+export type WidgetConfig = {
+    mountElementId: string;
+    configName?: string;
+    customerInteractionSession: CustomerInteractionSession;
+    agentId: string;
+    customerId?: string;
+    wsUrl: string;
+    apiUrl: string;
+    voiceModelId?: string;
+    voiceConfig?: {
+        voice: string;
+    };
+    AIAvatar?: boolean;
+    debug?: boolean;
+    avatarDebug?: boolean;
+    background?: boolean;
+    voiceEnabled?: boolean;
+    footer?: boolean;
+    /** When true, launcher + open/close behave as today. When false, closing hides the widget entirely until `setOpen(true)`. */
+    manualOpen?: boolean;
+    locale?: string;
+    /** Host-owned UI targets that commands are allowed to address. */
+    uiTargets?: Record<string, UiTarget>;
+    /** Optional host integrations. Built-in fallbacks cover CTA and data-lola highlights. */
+    commandHandlers?: HostCommandHandlers;
+    /** Lola SDK-compatible alias for commandHandlers. */
+    handlers?: HostCommandHandlers;
+};
+export declare class ChatWidgetInstance extends EventTarget {
+    constructor(config: WidgetConfig);
+    destroy(): void;
+    playAnimation(name: ExternallyAvailableActions): void;
+    setCustomerInteractionSession(session: CustomerInteractionSession): void;
+    setOpen(open: boolean): void;
+    setLocale(locale: string): void;
+    executeReaction(params: {
+        animation: string;
+        voice: string;
+        text: string;
+    }): void;
+    registerUiTarget(code: string, target: UiTarget): () => void;
+    registerCommandHandler<K extends HostCommandHandlerName>(name: K, handler: NonNullable<HostCommandHandlers[K]>): () => void;
+    addEventListener(type: "command_received" | "command_succeeded" | "command_failed" | "command_expired" | "command_unsupported", listener: (event: CustomEvent<CommandEventDetail>) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+}
+export type { CustomerInteractionSession };
+export type { CommandAck, CommandAckStatus, CommandEnvelope, CommandEventDetail, CommandType, CtaCommandContext, HighlightCommandContext, HostCommandContext, HostCommandHandler, HostCommandHandlerName, HostCommandHandlers, UiTarget, UiTargetKind, } from "./domain/command/command.types";

package/dist/lib/isSessionExpired.d.ts

@@ -0,0 +1,2 @@
+import type { CustomerInteractionSession } from "@/types";
+export declare function isSessionExpireInNextHour(session: CustomerInteractionSession): boolean;

package/dist/lib/logger.d.ts

@@ -0,0 +1,12 @@
+type LogLevel = "debug" | "info" | "warn" | "error";
+declare class Logger {
+    private level;
+    private prefix;
+    constructor(prefix?: string, level?: LogLevel);
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+export declare const logger: Logger;
+export {};

package/dist/lib/retrieveContent.d.ts

@@ -0,0 +1,6 @@
+import { type MessageData } from "@/api/messages.api.types";
+/**
+ * Plain-text preview from HTML for list items etc. Truncation works with CSS (e.g. truncate).
+ */
+export declare function htmlToPlainPreview(html: string, maxLength?: number): string;
+export declare function retrieveContent(m: MessageData): string;

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/lib//321/201ontentRenderer.d.ts

@@ -0,0 +1,6 @@
+import type { JSONContent } from "@/api/messages.api.types";
+/**
+ * Renders agent message content (TipTap JSON) to an HTML string.
+ * Uses the ProseMirror-free static JSON renderer.
+ */
+export declare function сontentToHtml(content: JSONContent | null | undefined): string;