@alxxsck/ai-assistant 2.14.0 → 2.16.0

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

@@ -7,16 +7,26 @@ export type CursorPage<T> = {
     items: T[];
     nextCursor: string | null;
 };
-type ConversationsResponse = CursorPage<ConversationData>;
+type VersionedCursorPage<T> = CursorPage<T> & {
+    contractVersion?: unknown;
+};
+type ConversationsResponse = VersionedCursorPage<ConversationData>;
 export declare class ChatApiError extends Error {
     readonly status: number;
     constructor(status: number, message: string);
 }
+export declare class ChatContractError extends Error {
+    constructor();
+}
 export declare const isConversationClosedError: (error: unknown) => boolean;
+export declare const requestChatJson: <T>(config: WidgetConfig, api: AppApi, path: string, init?: RequestInit) => Promise<T>;
+export declare const normalizeConversation: (conversation: ConversationData) => ConversationData;
 export declare const normalizeMessage: (message: RawMessageData, config: WidgetConfig) => MessageData;
+export declare const normalizeMessageForSession: (message: RawMessageData, interactionSessionId: string) => 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, signal?: AbortSignal) => Promise<ConversationData>;
+export declare const getConversation: (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}`, attachments?: readonly ChatAttachment[]): Promise<SendMessageResult>;
 export {};

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

@@ -17,6 +17,8 @@ export type ChatParticipant = {
     type: ParticipantType;
     displayName?: string;
     avatarUrl?: string | null;
+    role?: MessageRole;
+    presentation?: import("@/domain/support-presentation/support-presentation.types").MessageAuthorPresentation | null;
 };
 export type MessageDelivery = {
     id: string;
@@ -99,21 +101,20 @@ export type ConversationData = {
     };
     messages?: RawMessageData[];
     aiSuspension?: ConversationAISuspension;
+    responderPresentation?: import("@/domain/support-presentation/support-presentation.types").SafeResponderPresentation;
 };
+export type MessageRole = "USER" | "ASSISTANT" | "ADMIN" | "SCENARIO" | "SYSTEM";
 export type RawMessageData = {
     id: string;
     threadId: string;
-    role: "USER" | "ASSISTANT" | "ADMIN" | "SCENARIO" | "SYSTEM";
-    status: "COMPLETED" | "WRITING" | "FAILED";
+    role: MessageRole;
+    status: "COMPLETED" | "WRITING" | "FAILED" | "CANCELLED";
     text: string;
     content: JSONContent | null;
     commands: unknown[];
     ordinal?: number;
     clientMessageId?: string | null;
-    author?: {
-        displayName?: string;
-        avatarUrl?: string | null;
-    } | null;
+    author?: unknown;
     attachments?: ChatAttachment[];
     delivery?: MessageDelivery;
     createdAt: string;
@@ -128,6 +129,8 @@ export type AgenticStepsAppendedData = {
 };
 export type ChatMessageDeltaData = {
     messageId: string;
+    conversationId?: string;
+    requestId?: string;
     sequence: number;
     text: string;
     done: boolean;

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

@@ -1,4 +1,4 @@
-import { S as A, T as e, W as s, x as n, U as r } from "./index-mn1rW9m7.js";
+import { Z as A, _ as e, a0 as s, D as n, $ as r } from "./index-TodLTFY_.js";
 export {
   A as ChatWidgetInstance,
   e as EXTERNALLY_AVAILABLE_ACTIONS,

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

@@ -3,7 +3,7 @@ import type { CommandAck } from "@/domain/command/command.types";
 import type { CommandRuntime } from "@/domain/command/CommandRuntime";
 import type { MessageStoreActions } from "@/domain/message/message.store";
 type WidgetFrameDependencies = {
-    messageActions: Pick<MessageStoreActions, "handleConversationCreated" | "handleMessageDelta" | "handleMessagesAgenticSteps" | "handleMessage" | "handleChatTyping" | "handleSupportPresence">;
+    messageActions: Pick<MessageStoreActions, "handleConversationCreated" | "handleScenarioChoiceLifecycleChanged" | "handleScenarioChoiceSubmissionResult" | "handleMessageDelta" | "handleMessagesAgenticSteps" | "handleMessage" | "handleChatTyping" | "handleSupportPresence" | "handleResponderPresentationChanged">;
     commandRuntime: CommandRuntime;
     session: CustomerInteractionSession;
     sendAck: (ack: CommandAck) => Promise<unknown>;

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

@@ -1,5 +1,20 @@
 import type { AgenticStepsAppendedData, ChatMessageDeltaData, ConversationData, MessageData } from "@/api/messages.api.types";
-export declare const getConversationCreatedFromFrame: (frame: unknown) => ConversationData | null;
-export declare const getMessageFromFrame: (frame: unknown) => MessageData | null;
+import { type ScenarioChoiceLifecycleChanged, type ScenarioChoiceSubmissionResult } from "@/domain/scenario/scenario-choice";
+export type ScenarioConversationCreated = ConversationData & {
+    navigationEventId?: string;
+};
+export type ResponderPresentationChanged = Readonly<{
+    contractVersion: 1;
+    type: "conversation.responder_presentation.changed.v1";
+    eventId: string;
+    conversationId: string;
+    revision: string;
+    serverTime: string;
+}>;
+export declare const getConversationCreatedFromFrame: (frame: unknown) => ScenarioConversationCreated | null;
+export declare const getMessageFromFrame: (frame: unknown, interactionSessionId?: string) => MessageData | null;
 export declare const getMessageDeltaFromFrame: (frame: unknown) => ChatMessageDeltaData | null;
+export declare const getResponderPresentationChangedFromFrame: (frame: unknown) => ResponderPresentationChanged | null;
+export declare const getScenarioChoiceLifecycleChangedFromFrame: (frame: unknown) => ScenarioChoiceLifecycleChanged | null;
+export declare const getScenarioChoiceSubmissionResultFromFrame: (frame: unknown) => ScenarioChoiceSubmissionResult | null;
 export declare const getAgenticStepsFromFrame: (frame: unknown) => AgenticStepsAppendedData | null;

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

@@ -3,11 +3,17 @@ import type { AppApi } from "@/App";
 import type { WidgetConfig } from "@/index.types";
 import { type MessageStreamState } from "./message-stream";
 import type { ChatAttachment, ChatTypingState, SupportPresenceState } from "./chat-experience";
+import type { ResponderPresentationChanged, ScenarioConversationCreated } from "./cable/widget-message";
+import { type ScenarioChoiceLifecycleChanged, type ScenarioChoiceSubmissionResult } from "@/domain/scenario/scenario-choice";
 export interface ThreadSummary {
     threadId: string;
     lastMessage: MessageData;
 }
 export type AgentResponsePhase = "idle" | "awaiting-first-token" | "streaming";
+export type ConversationNavigationRequest = {
+    conversationId: string;
+    sequence: number;
+};
 export type PendingCustomerMessage = {
     id: string;
     text: string;
@@ -38,6 +44,10 @@ export type MessageStore = {
     api: AppApi | null;
     latestReadMessageDate: string | null;
     latestMessageDate: string | null;
+    conversationNavigationRequest: ConversationNavigationRequest | null;
+    scenarioChoiceLifecycleEvents: Map<string, ScenarioChoiceLifecycleChanged>;
+    scenarioChoiceSubmissionResults: Map<string, ScenarioChoiceSubmissionResult>;
+    handledConversationNavigationEventIds: Set<string>;
     messageStreams: Map<string, MessageStreamState>;
     pendingMessageDeltas: Map<string, ChatMessageDeltaData>;
     pendingCustomerMessage: PendingCustomerMessage | null;
@@ -50,10 +60,14 @@ export type MessageStore = {
 };
 export type MessageStoreActions = {
     initMessageStore: (config: WidgetConfig, api: AppApi) => Promise<void>;
+    disposeMessageStore: () => void;
     setCurrentThread: (conversationId: string) => Promise<void>;
     createNewConversation: () => Promise<string>;
-    handleConversationCreated: (conversation: ConversationData) => void;
+    handleConversationCreated: (conversation: ScenarioConversationCreated) => void;
+    handleScenarioChoiceLifecycleChanged: (event: ScenarioChoiceLifecycleChanged) => void;
+    handleScenarioChoiceSubmissionResult: (result: ScenarioChoiceSubmissionResult) => void;
     handleMessage: (message: MessageData) => void;
+    handleResponderPresentationChanged: (hint: ResponderPresentationChanged) => void;
     handleMessageDelta: (delta: ChatMessageDeltaData) => void;
     settleMessageStream: (messageId: string) => void;
     sendMessage: (message: string, attachments?: ChatAttachment[]) => Promise<SendMessageResult | undefined>;
@@ -83,10 +97,25 @@ export declare const useSelectThreadsPreviews: () => ThreadSummary[];
 export declare const useHasMoreConversations: () => boolean;
 export declare const useIsLoadingMoreConversations: () => boolean;
 export declare const useCurrentThreadId: () => string | undefined;
+export declare const useCurrentResponderPresentation: () => Readonly<{
+    contractState: "CURRENT" | "LEGACY" | "INCOMPATIBLE";
+    schemaVersion: 0 | 1;
+    mode: import("@/domain/support-presentation/support-presentation.types").ResponderMode | "UNKNOWN";
+    identity: import("@/domain/support-presentation/support-presentation.types").ResponderIdentity;
+    displayName: string | null;
+    avatarAsset: import("@/domain/support-presentation/support-presentation.types").PresentationAvatarAsset | null;
+    presentationVersion: number | null;
+    revision: string;
+    sourceRevisions: import("@/domain/support-presentation/support-presentation.types").ResponderSourceRevisions | null;
+    refreshAt: string | null;
+    serverTime: string | null;
+}>;
 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 useConversationNavigationRequest: () => ConversationNavigationRequest | null;
+export declare const useScenarioChoiceSubmissionResult: (clientEventId?: string) => ScenarioChoiceSubmissionResult | undefined;
 export declare const useSendError: () => string | null;
 export declare const selectIsCurrentThreadLoading: (state: MessageStore) => boolean;
 export declare const useIsCurrentThreadLoading: () => boolean;

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

@@ -3,15 +3,59 @@ export type ScenarioChoiceOption = {
     id: string;
     label: string;
 };
+export declare const SCENARIO_CHOICE_LIFECYCLE_STATUSES: readonly ["PENDING", "ANSWERED", "TIMED_OUT", "CANCELLED"];
+export type ScenarioChoiceLifecycleStatus = (typeof SCENARIO_CHOICE_LIFECYCLE_STATUSES)[number];
+export type ScenarioChoiceLifecycle = {
+    contractVersion: 1;
+    status: ScenarioChoiceLifecycleStatus;
+    serverTime: string;
+    expiresAt: string | null;
+    resolvedAt: string | null;
+    selectedOptionId: string | null;
+};
+export type ScenarioChoiceLifecycleChanged = {
+    contractVersion: 1;
+    type: "scenario.choice.lifecycle.changed.v1";
+    eventId: string;
+    revision: number;
+    inputRequestId: string;
+    conversationId: string;
+    messageId: string;
+    occurredAt: string;
+    serverTime: string;
+    lifecycle: ScenarioChoiceLifecycle;
+};
+export declare const SCENARIO_CHOICE_SUBMISSION_OUTCOMES: readonly ["ACCEPTED", "DUPLICATE", "TERMINAL", "NOT_READY", "REJECTED", "UNAVAILABLE"];
+export type ScenarioChoiceSubmissionResult = {
+    contractVersion: 1;
+    type: "scenario.choice.submission.result.v1";
+    clientEventId: string;
+    inputRequestId: string;
+    outcome: (typeof SCENARIO_CHOICE_SUBMISSION_OUTCOMES)[number];
+    ok: boolean;
+    accepted: boolean | null;
+    duplicate: boolean;
+    retryable: boolean;
+    errorCode: "SUBMISSION_HANDLER_FAILED" | null;
+    serverTime: string;
+};
 export type ScenarioChoiceCommand = {
     type: "ask_choice";
     inputRequestId: string;
     options: ScenarioChoiceOption[];
+    lifecycle?: ScenarioChoiceLifecycle;
 };
 export type ScenarioChoiceInput = {
     inputRequestId: string;
     optionId: string;
     clientEventId: string;
 };
+export declare const parseScenarioChoiceLifecycle: (value: unknown) => ScenarioChoiceLifecycle | null;
+export declare const parseScenarioChoiceLifecycleChanged: (value: unknown) => ScenarioChoiceLifecycleChanged | null;
+export declare const parseScenarioChoiceSubmissionResult: (value: unknown) => ScenarioChoiceSubmissionResult | null;
+export declare const applyScenarioChoiceLifecycle: (message: MessageData, event: ScenarioChoiceLifecycleChanged) => MessageData;
+export declare const projectScenarioChoiceLifecycle: (message: MessageData, inputRequestId: string, lifecycle: ScenarioChoiceLifecycle) => MessageData;
+export declare const isScenarioChoiceAvailable: (choice: ScenarioChoiceCommand, now?: number) => boolean;
+export declare const getScenarioChoiceRemainingMs: (choice: ScenarioChoiceCommand, now?: number) => number | null;
 export declare const getScenarioChoice: (message: MessageData) => ScenarioChoiceCommand | null;
-export declare const getLatestScenarioChoice: (messages: MessageData[]) => ScenarioChoiceCommand | null;
+export declare const getLatestScenarioChoice: (messages: MessageData[], now?: number) => ScenarioChoiceCommand | null;

package/dist/domain/support-presentation/PresentationAvatarResolver.d.ts

@@ -0,0 +1,55 @@
+import type { AppApi } from "@/App";
+import type { WidgetConfig } from "@/index.types";
+import { type PresentationAvatarGrant } from "./support-presentation-avatar.api";
+import type { PresentationAvatarAsset } from "./support-presentation.types";
+export type PresentationAvatarRequest = Readonly<{
+    conversationId: string;
+    asset: PresentationAvatarAsset;
+}>;
+export type ResolvedPresentationAvatar = Readonly<{
+    url: string;
+    expiresAt: string;
+}>;
+type FetchGrant = (config: WidgetConfig, api: AppApi, conversationId: string, asset: PresentationAvatarAsset, signal?: AbortSignal) => Promise<PresentationAvatarGrant>;
+type ResolverOptions = Readonly<{
+    fetchGrant?: FetchGrant;
+    now?: () => number;
+    sleep?: (milliseconds: number) => Promise<void>;
+    maxConcurrent?: number;
+    maxEntries?: number;
+    maxQueued?: number;
+}>;
+export declare class PresentationAvatarResolver {
+    private config;
+    private api;
+    private readonly fetchGrant;
+    private readonly now;
+    private readonly sleep;
+    private readonly maxConcurrent;
+    private readonly maxEntries;
+    private readonly maxQueued;
+    private readonly cache;
+    private readonly inFlight;
+    private readonly controllers;
+    private readonly queue;
+    private readonly authorityListeners;
+    private readonly conversationEpochs;
+    private activeCount;
+    private generation;
+    constructor(config: WidgetConfig, api: AppApi, options?: ResolverOptions);
+    resolve(request: PresentationAvatarRequest): Promise<ResolvedPresentationAvatar | null>;
+    private drainQueue;
+    private trimCache;
+    private loadGrant;
+    replaceSession(config: WidgetConfig, api: AppApi): void;
+    destroy(): void;
+    invalidate(request: PresentationAvatarRequest): void;
+    purgeConversation(conversationId: string): void;
+    subscribeAuthority: (listener: () => void) => (() => void);
+    getAuthoritySnapshot(conversationId: string): string;
+    private purgeKey;
+    private resetAuthority;
+    private notifyAuthorityChange;
+    private key;
+}
+export {};

package/dist/domain/support-presentation/SupportPresentationContext.d.ts

@@ -0,0 +1,12 @@
+import type { AppApi } from "@/App";
+import type { WidgetConfig } from "@/index.types";
+import { type PropsWithChildren } from "react";
+import { PresentationAvatarResolver } from "./PresentationAvatarResolver";
+type SupportPresentationProviderProps = PropsWithChildren<{
+    config: WidgetConfig;
+    api: AppApi;
+    authorizedConversationIds?: readonly string[];
+    resolver?: PresentationAvatarResolver;
+}>;
+export declare function SupportPresentationProvider({ children, config, api, authorizedConversationIds, resolver: suppliedResolver, }: SupportPresentationProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/domain/support-presentation/presentation-initials.d.ts

@@ -0,0 +1 @@
+export declare function presentationInitials(displayName: string): string;

package/dist/domain/support-presentation/support-presentation-avatar.api.d.ts

@@ -0,0 +1,13 @@
+import type { AppApi } from "@/App";
+import type { WidgetConfig } from "@/index.types";
+import type { PresentationAvatarAsset } from "./support-presentation.types";
+export type PresentationAvatarGrant = Readonly<{
+    assetId: string;
+    assetVersion: number;
+    url: string;
+    expiresAt: string;
+}>;
+export declare class PresentationAvatarContractError extends Error {
+    constructor();
+}
+export declare function getPresentationAvatarGrant(config: WidgetConfig, api: AppApi, conversationId: string, asset: PresentationAvatarAsset, signal?: AbortSignal): Promise<PresentationAvatarGrant>;

package/dist/domain/support-presentation/support-presentation-context.d.ts

@@ -0,0 +1,9 @@
+import type { PresentationAvatarResolver } from "./PresentationAvatarResolver";
+type SupportPresentationContextValue = {
+    resolver: PresentationAvatarResolver;
+    authorizedConversationIds: ReadonlySet<string> | null;
+};
+export declare const SupportPresentationContext: import("react").Context<SupportPresentationContextValue | null>;
+export declare const usePresentationAvatarResolver: () => PresentationAvatarResolver | null;
+export declare const usePresentationAvatarAuthorization: (conversationId: string) => boolean;
+export {};

package/dist/domain/support-presentation/support-presentation-observability.d.ts

@@ -0,0 +1,8 @@
+export type SupportPresentationObservation = Readonly<{
+    contractVersion: 1;
+    signal: "GRANT" | "RESOLVER" | "PROJECTION";
+    outcome: "CACHE_HIT" | "EXPIRED" | "REFRESHED" | "FALLBACK" | "REST_REALTIME_MISMATCH" | "REST_RECONCILED";
+}>;
+export declare const SUPPORT_PRESENTATION_OBSERVATION_EVENT = "lola:support-presentation-observation";
+/** Emits a bounded, identifier-free operational signal for the host telemetry bridge. */
+export declare function reportSupportPresentationObservation(observation: SupportPresentationObservation): void;

package/dist/domain/support-presentation/support-presentation.types.d.ts

@@ -0,0 +1,54 @@
+export type PresentationAvatarAsset = Readonly<{
+    id: string;
+    version: number;
+}>;
+export type MessageAuthorPresentation = Readonly<{
+    displayName: string;
+    avatarAsset: PresentationAvatarAsset | null;
+    presentationVersion: number | null;
+    legacyAvatarUrl: string | null;
+}>;
+export declare const RESPONDER_MODES: readonly ["LOLA", "SUPPORT_REQUESTED", "SUPPORT_LIVE", "SUPPORT_AWAY", "LOLA_SUSPENDED"];
+export type ResponderMode = (typeof RESPONDER_MODES)[number];
+export type ResponderIdentity = "LOLA" | "SUPPORT";
+export type ResponderSourceRevisions = Readonly<{
+    conversationUpdatedAt: string;
+    escalationVersionSum: string;
+    escalationUpdatedAt: string | null;
+    aiSuspensionVersion: string | null;
+    aiSuspensionUpdatedAt: string | null;
+    lolaPresentationVersion: number | null;
+    operatorPresentationVersion: number | null;
+    avatarAssetUpdatedAt: string | null;
+}>;
+export type ResponderPresentation = Readonly<{
+    schemaVersion: 1;
+    mode: ResponderMode;
+    identity: ResponderIdentity;
+    displayName: string;
+    avatarAsset: PresentationAvatarAsset | null;
+    presentationVersion: number | null;
+    revision: string;
+    sourceRevisions: ResponderSourceRevisions;
+    refreshAt: string | null;
+    serverTime: string;
+}>;
+export type SafeResponderPresentation = Readonly<{
+    contractState: "CURRENT" | "LEGACY" | "INCOMPATIBLE";
+    schemaVersion: 0 | 1;
+    mode: ResponderMode | "UNKNOWN";
+    identity: ResponderIdentity;
+    displayName: string | null;
+    avatarAsset: PresentationAvatarAsset | null;
+    presentationVersion: number | null;
+    revision: string;
+    sourceRevisions: ResponderSourceRevisions | null;
+    refreshAt: string | null;
+    serverTime: string | null;
+}>;
+export declare const LEGACY_RESPONDER_PRESENTATION: SafeResponderPresentation;
+export declare const INCOMPATIBLE_RESPONDER_PRESENTATION: SafeResponderPresentation;
+export declare function parseMessageAuthorPresentation(value: unknown): MessageAuthorPresentation | null;
+export declare function parseResponderPresentation(value: unknown): ResponderPresentation | null;
+export declare function normalizeResponderPresentation(value: unknown): SafeResponderPresentation;
+export declare function getResponderRefreshDelay(presentation: SafeResponderPresentation): number | null;

package/dist/i18n/messages.d.ts

@@ -22,6 +22,16 @@ declare const en: {
     readonly avatar: {
         readonly gettingReady: "Lola is getting ready…";
     };
+    readonly identity: {
+        readonly support: "Support";
+        readonly system: "System";
+        readonly aiAssistant: "AI assistant";
+        readonly waiting: "Waiting for a specialist";
+        readonly live: "Specialist is here";
+        readonly away: "We’ll reply here";
+        readonly paused: "AI is paused";
+        readonly unavailable: "Support status unavailable";
+    };
     readonly chat: {
         readonly back: "Back to chat";
         readonly listTitle: "Chats";