@alxxsck/ai-assistant 2.5.1 → 2.7.0

package/dist/api/messages.api.d.ts

@@ -2,19 +2,20 @@ import type { AppApi } from "@/App";
 import type { WidgetConfig } from "@/index.types";
 import { type ConversationData, type MessageData, type RawMessageData } from "./messages.api.types";
 export declare const MAX_FETCH_MESSAGES = 100;
-type ConversationsResponse = {
-    items: ConversationData[];
+export type CursorPage<T> = {
+    items: T[];
     nextCursor: string | null;
 };
+type ConversationsResponse = CursorPage<ConversationData>;
 export declare class ChatApiError extends Error {
     readonly status: number;
     constructor(status: number, message: string);
 }
 export declare const isConversationClosedError: (error: unknown) => boolean;
 export declare const normalizeMessage: (message: RawMessageData, config: WidgetConfig) => MessageData;
-export declare const listConversations: (config: WidgetConfig, api: AppApi) => Promise<ConversationsResponse>;
-export declare const listConversationMessages: (config: WidgetConfig, api: AppApi, conversationId: string) => Promise<MessageData[]>;
+export declare const listConversations: (config: WidgetConfig, api: AppApi, cursor?: string, signal?: AbortSignal) => Promise<ConversationsResponse>;
+export declare const listConversationMessages: (config: WidgetConfig, api: AppApi, conversationId: string, cursor?: string, signal?: AbortSignal) => Promise<CursorPage<MessageData>>;
 export declare const createConversation: (config: WidgetConfig, api: AppApi) => Promise<ConversationData>;
-export declare const selectConversation: (config: WidgetConfig, api: AppApi, conversationId: string) => Promise<ConversationData>;
+export declare const selectConversation: (config: WidgetConfig, api: AppApi, conversationId: string, signal?: AbortSignal) => Promise<ConversationData>;
 export declare function sendMessage(config: WidgetConfig, api: AppApi, messageText: string, conversationId?: string, clientMessageId?: `${string}-${string}-${string}-${string}-${string}`): Promise<MessageData>;
 export {};

package/dist/avatar/publicAnimations.d.ts

@@ -1,3 +1,3 @@
-export declare const EXTERNALLY_AVAILABLE_ACTIONS: readonly ["dancing", "deposit", "excited", "fix_hair", "kiss", "spin", "win_small"];
+export declare const EXTERNALLY_AVAILABLE_ACTIONS: readonly ["deposit", "excited", "fix_hair", "kiss", "spin", "win_small"];
 export type ExternallyAvailableActions = (typeof EXTERNALLY_AVAILABLE_ACTIONS)[number];
 export declare function isExternallyAvailableAction(value: string): value is ExternallyAvailableActions;

package/dist/bridge-ai-chat-widget.es.js

@@ -1,6 +1,7 @@
-import { D as t, E as e, F as s } from "./index-D9W50u8W.js";
+import { J as L, K as s, S as t, L as E } from "./index-Cyv8CKEt.js";
 export {
-  t as ChatWidgetInstance,
-  e as EXTERNALLY_AVAILABLE_ACTIONS,
-  s as isExternallyAvailableAction
+  L as ChatWidgetInstance,
+  s as EXTERNALLY_AVAILABLE_ACTIONS,
+  t as SUPPORTED_LOCALES,
+  E as isExternallyAvailableAction
 };

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

@@ -21,8 +21,13 @@ export type MessageStore = {
     currentThreadMessages: MessageData[];
     messages: MessageData[];
     conversations: ConversationData[];
+    conversationsNextCursor: string | null;
+    isLoadingMoreConversations: boolean;
     threadIds: string[];
     loadedThreadIds: Set<string>;
+    threadMessagesNextCursor: Map<string, string | null>;
+    loadingOlderThreadIds: Set<string>;
+    refreshingThreadIds: Set<string>;
     threads: Map<string, MessageData[]>;
     threadsPreviews: ThreadSummary[];
     sendError: string | null;
@@ -54,16 +59,24 @@ export type MessageStoreActions = {
     handleMessagesAgenticSteps: (message: AgenticStepsAppendedData) => void;
     updateThreads: () => void;
     fetchThreadMessages: (conversationId: string) => Promise<void>;
+    fetchOlderThreadMessages: (conversationId: string) => Promise<void>;
+    cancelThreadMessagesRequest: (conversationId: string) => void;
+    cancelConversationPagination: () => void;
     setCurrentThreadMessages: (conversationId: string) => void;
     sendServiceMessage: (message: string) => Promise<void>;
     updateConfig: (config: WidgetConfig, api: AppApi) => void;
-    recoverMessages: () => Promise<void>;
+    recoverMessages: (preserveLoadedConversations?: boolean) => Promise<void>;
+    fetchMoreConversations: () => 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 useHasMoreConversations: () => boolean;
+export declare const useIsLoadingMoreConversations: () => boolean;
 export declare const useCurrentThreadId: () => string | undefined;
+export declare const useCurrentThreadHasOlderMessages: () => boolean;
+export declare const useIsLoadingOlderCurrentThread: () => boolean;
 export declare const useLatestReadMessageDate: () => string | null;
 export declare const useLatestMessageDate: () => string | null;
 export declare const useSendError: () => string | null;

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

@@ -4,12 +4,14 @@ import type { VoiceSessionData } from "@/api/voice.api.types";
 import type { SpeakTextCommandContext, StartVoiceConversationCommandContext } from "@/domain/command/command.types";
 import type { WidgetConfig } from "@/index.types";
 type VoiceStatus = "idle" | "connecting" | "listening" | "speaking" | "error";
+export type VoiceErrorCode = "audio_playback_failed" | "session_failed" | "connection_closed" | "connection_timed_out" | "microphone_blocked" | "microphone_unsupported";
 type VoiceStore = {
     config: WidgetConfig | null;
     api: AppApi | null;
     session: VoiceSessionData | null;
     status: VoiceStatus;
     errorMessage: string | null;
+    errorCode: VoiceErrorCode | null;
     socket: Socket | null;
     localStream: MediaStream | null;
     inputAudioContext: AudioContext | null;

package/dist/i18n/I18nProvider.d.ts

@@ -0,0 +1,4 @@
+import { type PropsWithChildren } from "react";
+export declare function I18nProvider({ children, locale: localeTag, }: PropsWithChildren<{
+    locale?: string;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/i18n/i18n-context.d.ts

@@ -0,0 +1,9 @@
+import { type SupportedLocale } from "./i18n";
+import { type TranslationKey } from "./messages";
+export type I18nContextValue = {
+    locale: SupportedLocale;
+    direction: "ltr" | "rtl";
+    t: (key: TranslationKey, params?: Record<string, string | number>) => string;
+};
+export declare const createI18nValue: (localeTag?: string) => I18nContextValue;
+export declare const I18nContext: import("react").Context<I18nContextValue>;

package/dist/i18n/i18n.d.ts

@@ -0,0 +1,3 @@
+export declare const SUPPORTED_LOCALES: readonly ["ru", "uz", "en", "it", "es", "de", "fr", "pl", "pt", "bn", "sw", "so", "ar"];
+export type SupportedLocale = (typeof SUPPORTED_LOCALES)[number];
+export declare function normalizeLocale(locale?: string): SupportedLocale;

package/dist/i18n/messages.d.ts

@@ -0,0 +1,101 @@
+import { type SupportedLocale } from "./i18n";
+declare const en: {
+    readonly app: {
+        readonly restart: "Restart Lola";
+    };
+    readonly launcher: {
+        readonly open: "Open Lola";
+    };
+    readonly widget: {
+        readonly resizeVertical: "Resize Lola vertically";
+        readonly resizeHorizontal: "Resize Lola horizontally";
+        readonly resizeDiagonal: "Resize Lola diagonally";
+        readonly resize: "Resize Lola";
+    };
+    readonly controls: {
+        readonly close: "Close chat";
+        readonly move: "Move Lola";
+        readonly exitFullscreen: "Exit fullscreen";
+        readonly enterFullscreen: "Enter fullscreen";
+        readonly openChatList: "Open chat list";
+    };
+    readonly avatar: {
+        readonly gettingReady: "Lola is getting ready…";
+    };
+    readonly chat: {
+        readonly back: "Back to chat";
+        readonly listTitle: "Chats";
+        readonly new: "New chat";
+        readonly loadOlder: "Load older chats";
+        readonly retryOlder: "Retry older chats";
+        readonly olderLoadFailed: "Couldn't load older chats.";
+        readonly loadingOlder: "Loading older chats";
+        readonly loadPreviousMessages: "Load previous messages";
+        readonly retryPreviousMessages: "Retry previous messages";
+        readonly previousLoadFailed: "Couldn't load previous messages.";
+        readonly loadingOlderMessages: "Loading older messages";
+        readonly loadingMessages: "Loading messages";
+        readonly switchToVoice: "Switch to voice chat";
+        readonly talk: "Talk";
+        readonly messageLabel: "Message";
+        readonly messagePlaceholder: "Message…";
+        readonly send: "Send message";
+        readonly thinking: "AI is thinking";
+        readonly unread: "Unread messages";
+        readonly chooseAnswer: "Choose an answer";
+        readonly answerSent: "Answer sent";
+        readonly answerFailed: "Failed to send. Tap again to retry.";
+    };
+    readonly error: {
+        readonly connectionFailed: "Connection failed";
+        readonly offline: "You're offline";
+        readonly agentResponseFailed: "Assistant response failed";
+        readonly sendMessageFailed: "Failed to send message";
+        readonly conversationClosed: "This chat is closed. Select or create another chat.";
+    };
+    readonly voice: {
+        readonly connecting: "Connecting…";
+        readonly speaking: "Assistant speaking…";
+        readonly incoming: "Incoming voice conversation";
+        readonly startTalking: "Start talking";
+        readonly muted: "Muted";
+        readonly calling: "Lola is calling";
+        readonly aiDisclosure: "The voice you hear is generated by AI.";
+        readonly accept: "Accept";
+        readonly decline: "Decline";
+        readonly muteMicrophone: "Mute microphone";
+        readonly unmuteMicrophone: "Unmute microphone";
+        readonly switchToText: "Switch to text chat";
+        readonly audioPlaybackFailed: "Couldn't play the assistant's voice.";
+        readonly sessionFailed: "Voice conversation failed.";
+        readonly connectionClosed: "Voice connection was closed.";
+        readonly connectionTimedOut: "Voice connection timed out.";
+        readonly microphoneBlocked: "The browser blocked microphone access.";
+        readonly microphoneUnsupported: "This browser doesn't support microphone access.";
+    };
+    readonly cta: {
+        readonly dismiss: "Dismiss action";
+        readonly openTelegram: "Open @{{username}}";
+        readonly manualCommand: "If the link doesn't work:";
+        readonly telegramPopupOpened: "Tap Start in Telegram, then come back here and confirm the connection.";
+        readonly telegramPopupBlocked: "Open the bot using the link below, tap Start, then come back to confirm.";
+        readonly telegramLinkFailed: "Couldn't create the Telegram link. Try again.";
+        readonly telegramLinkExpired: "The link expired. Tap the button to create a new one.";
+        readonly telegramPressStart: "First tap Start in Telegram, then confirm the connection here.";
+        readonly telegramConnectFailed: "Couldn't connect Telegram. Try again.";
+        readonly preparingLink: "Preparing the link…";
+        readonly confirmTelegram: "Confirm Telegram";
+        readonly confirming: "Confirming…";
+    };
+};
+type CatalogShape = {
+    [Group in keyof typeof en]: {
+        [Key in keyof (typeof en)[Group]]: string;
+    };
+};
+export type TranslationKey = {
+    [Group in keyof CatalogShape & string]: `${Group}.${keyof CatalogShape[Group] & string}`;
+}[keyof CatalogShape & string];
+export type TranslationMessages = Record<TranslationKey, string>;
+export declare const MESSAGES: Record<SupportedLocale, TranslationMessages>;
+export {};

package/dist/i18n/useI18n.d.ts

@@ -0,0 +1,2 @@
+import { type I18nContextValue } from "./i18n-context";
+export declare function useI18n(): I18nContextValue;