@alxxsck/ai-assistant 1.8.0 → 2.2.0

package/dist/config/runtime-config.d.ts

@@ -0,0 +1,4 @@
+export declare const LOLA_API_URL: string;
+export declare const LOLA_WS_URL: any;
+export declare const AI_ASSISTANT_ASSETS_URL: string;
+export declare const getAuthenticatedLolaWsUrl: (accessToken: string) => string;

package/dist/context/ChatWidgetContext.d.ts

@@ -5,12 +5,13 @@ 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)`. */
+    isFullscreen: boolean;
+    setFullscreen: (fullscreen: boolean) => void;
+    contentActivated: boolean;
+    isAvatarCoveredByChatList: boolean;
+    setAvatarCoveredByChatList: (covered: boolean) => void;
+    /** False after a hidden-launcher widget is closed 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;

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

@@ -30,6 +30,7 @@ export declare class CommandRuntime {
     private executeHighlight;
     private executeShowCta;
     private requireTarget;
+    private readLipSyncDescriptor;
     private requireEnvelopeTarget;
     private findTargetElement;
     private applyDefaultHighlight;

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

@@ -61,42 +61,19 @@ 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 OpenPageContext = {
     commandId: string;
     pageCode: string;
     route: string;
     payload: Readonly<Record<string, unknown>>;
-    /** @deprecated Use pageCode. */
-    target: string;
-    /** @deprecated The command type is fixed for this callback. */
-    commandType: "open_page";
-    /** @deprecated Use route. */
-    url: string;
-    /** @deprecated Used only by legacy local target integrations. */
-    targetDefinition?: UiTarget;
 };
 export type OpenModalContext = {
     commandId: string;
     modalCode: string;
     modalName: string;
     payload: Readonly<Record<string, unknown>>;
-    /** @deprecated Use modalCode. */
-    target: string;
-    /** @deprecated The command type is fixed for this callback. */
-    commandType: "open_modal";
-    /** @deprecated Use modalCode. */
-    modalId: string;
-    /** @deprecated Used only by legacy URL-based modal integrations. */
-    url?: string;
-    /** @deprecated Used only by legacy local target integrations. */
-    targetDefinition?: UiTarget;
 };
 export type UiCommandActionSnapshot = {
     kind: "page";
@@ -142,12 +119,26 @@ export type SpeakTextCommandContext = {
     format: "pcm16";
     sampleRate: 24_000;
     channels: 1;
+    lipSync?: LipSyncPlaybackDescriptor;
+};
+export type LipSyncPlaybackDescriptor = {
+    contractVersion: 1;
+    playbackId: string;
+    audio: {
+        encoding: "pcm_s16le";
+        sampleRate: 24_000;
+        channels: 1;
+    };
+    cueTimebase: "milliseconds";
+    transport: {
+        socketIoEvent: "lip_sync.cues";
+        cableField: "lipSyncCues";
+    };
 };
 export type HostCommandHandlers = {
     openPage?: (context: OpenPageContext) => void | Promise<void>;
     openModal?: (context: OpenModalContext) => 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]>;

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

@@ -7,12 +7,13 @@ import type { ScenarioChoiceInput } from "@/domain/scenario/scenario-choice";
  * subscribing to channels.
  */
 export declare class AnyCableService {
+    private readonly onAuthenticationError?;
     private url;
     private cable?;
     channels: {
         chat: WidgetChatChannel;
     };
-    constructor(url: string, onMessage?: (message: unknown) => void);
+    constructor(url: string, onMessage?: (message: unknown) => void, onAuthenticationError?: (() => void) | undefined);
     /**
      * Subscribes to a channel
      *

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

@@ -11,7 +11,8 @@ interface CableProviderProps {
     children: ReactNode;
     config: WidgetConfig;
     commandRuntime: CommandRuntime;
+    onSessionExpired?: () => void;
 }
-export declare const CableProvider: ({ children, config, commandRuntime, }: CableProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CableProvider: ({ children, config, commandRuntime, onSessionExpired, }: CableProviderProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useCable: () => CableContextType;
 export {};

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

@@ -7,13 +7,11 @@ export declare enum NetworkStatus {
      */
     Available = "available",
     /**
-     * When the user is offline (no internet access) but WS connection is
-     * established
+     * When the browser reports that the user has no network access
      */
     Offline = "offline",
     /**
-     * When the user is offline (no internet access) and WS connection is not
-     * established
+     * When the browser is online but the WS connection is not established
      */
     Unavailable = "unavailable"
 }

package/dist/domain/speech/LipSyncCueSource.d.ts

@@ -0,0 +1,25 @@
+import type { Viseme } from "./LipSyncRuntime";
+import { LipSyncRuntime } from "./LipSyncRuntime";
+export type TimedLipSyncCue = Readonly<{
+    viseme: Viseme;
+    startMs: number;
+    endMs: number;
+}>;
+export type TimedLipSyncCueBatch = Readonly<{
+    playbackId: string;
+    sequence: number;
+    cues: readonly TimedLipSyncCue[];
+}>;
+export interface LipSyncCueSource {
+    read(request: {
+        playbackId: string;
+        signal: AbortSignal;
+    }): AsyncIterable<TimedLipSyncCueBatch>;
+}
+export declare function consumeLipSyncCueSource({ source, runtime, playbackId, sampleRate, signal, }: {
+    source: LipSyncCueSource;
+    runtime: LipSyncRuntime;
+    playbackId: string;
+    sampleRate: number;
+    signal: AbortSignal;
+}): Promise<void>;

package/dist/domain/speech/LipSyncRuntime.d.ts

@@ -0,0 +1,54 @@
+export type LipSyncPhase = "idle" | "playing" | "underrun";
+export type Viseme = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "X";
+export type LipSyncCue = Readonly<{
+    viseme: Viseme;
+    startSample: number;
+    endSample: number;
+}>;
+export type LipSyncSnapshot = Readonly<{
+    playbackId: string | null;
+    phase: LipSyncPhase;
+    sampleRate: number;
+    sourceSample: number;
+    mouthOpen: number;
+    activeViseme: Viseme | null;
+}>;
+export type LipSyncEvent = Readonly<{
+    type: "playback-started";
+    playbackId: string;
+    sampleRate: number;
+}> | Readonly<{
+    type: "playback-progress";
+    playbackId: string;
+    sourceSample: number;
+    mouthOpen: number;
+}> | Readonly<{
+    type: "playback-stopped";
+    playbackId: string;
+}> | Readonly<{
+    type: "playback-underrun" | "playback-resumed";
+    playbackId: string;
+}> | Readonly<{
+    type: "cue-batch";
+    playbackId: string;
+    sequence: number;
+    cues: readonly LipSyncCue[];
+}>;
+type LipSyncListener = (snapshot: LipSyncSnapshot) => void;
+export declare class LipSyncRuntime {
+    private snapshot;
+    private readonly listeners;
+    private cues;
+    private cueIndex;
+    private nextCueSequence;
+    private cuesEnabled;
+    private rmsMouthOpen;
+    dispatch(event: LipSyncEvent): void;
+    subscribe(listener: LipSyncListener): () => void;
+    private publish;
+    private notify;
+    private deriveSnapshot;
+    private acceptCueBatch;
+}
+export declare const lipSyncRuntime: LipSyncRuntime;
+export {};

package/dist/domain/speech/RealtimeLipSyncCueSource.d.ts

@@ -0,0 +1,13 @@
+import type { LipSyncCueSource, TimedLipSyncCueBatch } from "./LipSyncCueSource";
+export declare class RealtimeLipSyncCueSource implements LipSyncCueSource {
+    private readonly playbacks;
+    private readonly terminalPlaybackIds;
+    publish(value: unknown): void;
+    read({ playbackId, signal, }: {
+        playbackId: string;
+        signal: AbortSignal;
+    }): AsyncIterable<TimedLipSyncCueBatch>;
+    private bufferFor;
+    private markTerminal;
+}
+export declare const realtimeLipSyncCueSource: RealtimeLipSyncCueSource;

package/dist/domain/speech/SpeechPlayer.d.ts

@@ -1,11 +1,21 @@
 export type SpeechPlaybackOptions = {
     onStarted?: () => void;
+    onStopped?: (completed: boolean) => void;
 };
 export type PcmStreamLoader = (signal: AbortSignal) => Promise<ReadableStream<Uint8Array>>;
 export type PcmPlaybackOptions = SpeechPlaybackOptions & {
     sampleRate: number;
     jitterBufferMs?: number;
+    onProgress?: (progress: PcmPlaybackProgress) => void;
+    onUnderrun?: () => void;
+    onResumed?: () => void;
 };
+export type PcmPlaybackProgress = Readonly<{
+    sourceSample: number;
+    renderContextFrame: number;
+    mouthOpen: number;
+    peak: number;
+}>;
 export declare class SpeechPlayer {
     private active;
     get isPlaying(): boolean;

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

@@ -1,7 +1,13 @@
-type WidgetUIData = {
+import type { Point } from "./widget-geometry";
+type PanelGeometry = Partial<Point> & {
     width: number;
     height: number;
 };
+export type WidgetUIData = {
+    version: 2;
+    launcher?: Point;
+    panel: PanelGeometry;
+};
 export declare function loadWidgetUIData(): WidgetUIData | null;
 export declare function saveWidgetUIData(data: WidgetUIData): void;
 export {};

package/dist/domain/ui/widget-geometry.d.ts

@@ -0,0 +1,23 @@
+export type Point = {
+    x: number;
+    y: number;
+};
+export type Size = {
+    width: number;
+    height: number;
+};
+export type Rect = Point & Size;
+export type Viewport = Size;
+export declare const LAUNCHER_SIZE = 52;
+export declare const VIEWPORT_MARGIN = 16;
+export declare const MIN_WIDGET_WIDTH = 240;
+export declare const DEFAULT_WIDGET_WIDTH = 360;
+export declare const MIN_WIDGET_HEIGHT = 320;
+export declare const DEFAULT_WIDGET_HEIGHT = 680;
+export declare function getViewport(): Viewport;
+export declare function getDefaultLauncherPosition(viewport: Viewport): Point;
+export declare function clampLauncherPosition(point: Point, viewport: Viewport): Point;
+export declare function clampPanelRect(rect: Rect, viewport: Viewport): Rect;
+export declare function placePanelFromLauncher(launcher: Point, size: Size, viewport: Viewport): Rect;
+export declare function resizePanelFromNorthWest(start: Rect, delta: Point, axes: "top" | "left" | "corner", viewport: Viewport): Rect;
+export declare function resizePanelFromSouthEast(start: Rect, delta: Point, viewport: Viewport): Rect;

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

@@ -25,6 +25,7 @@ type VoiceStore = {
     actions: VoiceStoreActions;
 };
 type VoiceStoreActions = {
+    updateSession: (config: WidgetConfig, api: AppApi) => Promise<void>;
     startListening: (config: WidgetConfig, api: AppApi) => Promise<void>;
     offerConversation: (invitation: StartVoiceConversationCommandContext) => Promise<void>;
     acceptConversation: (config: WidgetConfig, api: AppApi) => Promise<void>;