@alxxsck/ai-assistant 2.18.0 → 2.20.0

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

@@ -1,4 +1,4 @@
-import { a0 as A, a1 as e, a3 as s, G as n, a2 as r } from "./index-raaheNwM.js";
+import { a2 as A, a3 as e, a5 as s, H as n, a4 as r } from "./index-BVQY-1rm.js";
 export {
   A as ChatWidgetInstance,
   e as EXTERNALLY_AVAILABLE_ACTIONS,

package/dist/context/ChatWidgetContext.d.ts

@@ -2,9 +2,12 @@ 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";
+import type { SurfaceTransitionContext } from "@/domain/scenario-interaction/scenario-interaction.types";
 type ChatWidgetContextValue = {
     open: boolean;
     setOpen: (v: boolean) => void;
+    transitionSurface: (open: boolean, context: SurfaceTransitionContext) => void;
+    surfaceEpisodeId: string | null;
     isFullscreen: boolean;
     setFullscreen: (fullscreen: boolean) => void;
     contentActivated: boolean;

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

@@ -1,9 +1,10 @@
 import type { CustomerInteractionSession } from "@/types";
 import { type CommandAck, type CommandEnvelope, type CommandEventDetail, type CtaCommandContext, type HostCommandHandlerName, type HostCommandHandlers, type SpeakTextCommandContext, type StartVoiceConversationCommandContext, type UiTarget } from "./command.types";
+import type { ScenarioInteractionRuntime } from "@/domain/scenario-interaction/ScenarioInteractionRuntime";
 type AckSender = (ack: CommandAck) => Promise<unknown>;
 type InternalHandlers = {
-    setAssistantVisible?: (visible: boolean) => void;
-    setChatOpen?: (open: boolean) => void;
+    setAssistantVisible?: (visible: boolean, commandId: string) => void;
+    setChatOpen?: (open: boolean, commandId: string) => void;
     playAnimation?: (animation: string, expiresAt?: string | null) => void | Promise<void>;
     showCta?: (context: CtaCommandContext) => void;
     connectTelegram?: (context: CtaCommandContext) => void | Promise<void>;
@@ -12,6 +13,7 @@ type InternalHandlers = {
 };
 export declare class CommandRuntime {
     private readonly onStatus?;
+    private readonly scenarioInteractions?;
     private readonly uiCommands;
     private readonly internalHandlers;
     private readonly internalHandlersReady;
@@ -19,16 +21,25 @@ export declare class CommandRuntime {
     private readonly completed;
     private readonly inFlight;
     private readonly highlights;
-    constructor(targets?: Record<string, UiTarget>, handlers?: HostCommandHandlers, onStatus?: ((detail: CommandEventDetail) => void) | undefined);
+    private readonly targetObservationCleanups;
+    private readonly targetActivationOwners;
+    private readonly activeCustomHighlights;
+    private readonly targetHighlightOperations;
+    private principalSessionId;
+    private principalGeneration;
+    private destroyed;
+    constructor(targets?: Record<string, UiTarget>, handlers?: HostCommandHandlers, onStatus?: ((detail: CommandEventDetail) => void) | undefined, scenarioInteractions?: ScenarioInteractionRuntime | 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>;
+    updateSession(session: CustomerInteractionSession): void;
     executeCtaAction(context: CtaCommandContext): Promise<void>;
     destroy(): void;
     private executeOnce;
     private dispatch;
     private executeHighlight;
+    private executeHighlightSerial;
     private executeShowCta;
     private executeConnectTelegram;
     private requireTarget;
@@ -37,10 +48,22 @@ export declare class CommandRuntime {
     private findTargetElement;
     private applyDefaultHighlight;
     private removeDefaultHighlight;
+    private observeTarget;
+    private createTargetActivationReporter;
+    private removeTargetObservation;
+    private removeTargetTracking;
+    private deactivateCustomHighlight;
+    private removeCustomHighlightForCommand;
+    private invokeCustomHighlight;
+    private queueCustomHighlightCleanup;
+    private clearCustomHighlights;
     private requireInternal;
     private requireString;
     private firstDefined;
     private finish;
+    private ensurePrincipal;
+    private resetPrincipalState;
+    private isCurrentPrincipal;
     private storageKey;
     private loadCompleted;
     private saveCompleted;

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

@@ -91,6 +91,12 @@ export type UiCommandActionSnapshot = {
 export type HighlightCommandContext = HostCommandContext & {
     active: boolean;
     element?: Element;
+    /**
+     * Reports the product action caused by this active highlight. Call it
+     * synchronously from the host-owned action handler, before navigation. The
+     * SDK records only that activation happened; it does not infer its outcome.
+     */
+    reportActivation: () => void;
 };
 export type CtaCommandContext = Omit<HostCommandContext, "target"> & {
     label: string;

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

@@ -3,8 +3,10 @@ import { AnyCableService } from "./AnyCable.service";
 import { NetworkStatus } from "./CableContext.types";
 import type { WidgetConfig } from "@/index.types";
 import type { CommandRuntime } from "@/domain/command/CommandRuntime";
+import { EndUserTypingClient } from "@/domain/message/typing/end-user-typing.client";
 interface CableContextType {
     anycableService: AnyCableService | null;
+    endUserTypingClient: EndUserTypingClient;
     networkStatus: NetworkStatus;
 }
 interface CableProviderProps {

package/dist/domain/message/typing/end-user-typing.client.d.ts

@@ -0,0 +1,38 @@
+export declare const END_USER_TYPING_IDLE_MS = 2000;
+export declare const END_USER_TYPING_RENEW_MS = 3000;
+export type EndUserTypingCommand = Readonly<{
+    conversationId: string;
+    isTyping: boolean;
+}>;
+export interface EndUserTypingSocket {
+    isConnected(): boolean;
+    onConnect(listener: () => void): void;
+    offConnect(listener: () => void): void;
+    connect(): void;
+    disconnect(): void;
+    send(command: EndUserTypingCommand): void;
+}
+type EndUserTypingSocketFactory = (accessToken: string) => EndUserTypingSocket;
+/**
+ * Sends content-free, volatile typing hints for the one conversation being edited.
+ * The socket is created lazily and no command is queued while the transport is offline.
+ */
+export declare class EndUserTypingClient {
+    private readonly accessToken;
+    private readonly socketFactory;
+    private readonly now;
+    private socket;
+    private conversationId;
+    private lastPublicationAt;
+    private idleTimer;
+    constructor(accessToken: string, socketFactory?: EndUserTypingSocketFactory, now?: () => number);
+    markActivity(conversationId: string): void;
+    stop(): void;
+    dispose(): void;
+    private readonly handleConnect;
+    private publish;
+    private ensureSocket;
+    private scheduleIdleStop;
+    private clearIdleTimer;
+}
+export {};

package/dist/domain/scenario-interaction/ScenarioInteractionCollector.d.ts

@@ -0,0 +1,91 @@
+import type { CustomerInteractionSession } from "@/types";
+import { type ScenarioInteractionDraft, type ScenarioInteractionObservation } from "./scenario-interaction.types";
+type CollectorOptions = {
+    baseUrl?: string;
+    queueLimit?: number;
+    batchLimit?: number;
+    flushIntervalMs?: number;
+    requestTimeoutMs?: number;
+    fetch?: typeof fetch;
+    createId?: () => string;
+    now?: () => number;
+    random?: () => number;
+};
+export declare class ScenarioInteractionCollector {
+    private readonly getSession;
+    private readonly onSessionExpired;
+    private readonly queue;
+    private readonly baseUrl;
+    private readonly queueLimit;
+    private readonly batchLimit;
+    private readonly flushIntervalMs;
+    private readonly requestTimeoutMs;
+    private readonly fetchImpl;
+    private readonly createId;
+    private readonly now;
+    private readonly random;
+    private sequence;
+    private capabilities;
+    private capabilityRequest;
+    private flushRequest;
+    private capabilityRequestControl;
+    private batchRequestControl;
+    private batchRequestUsesKeepalive;
+    private flushTimer;
+    private retryTimer;
+    private capabilityRetryTimer;
+    private retryAttempt;
+    private capabilityRetryAttempt;
+    private batchRetriesSuspended;
+    private capabilityRetriesSuspended;
+    private awaitingRenewalToken;
+    private sessionGeneration;
+    private quotaBlockedUntil;
+    private admissionWindowStartedAt;
+    private admissionCount;
+    private started;
+    private destroyed;
+    private principalSessionId;
+    private principalAccessToken;
+    constructor(getSession: () => CustomerInteractionSession, onSessionExpired: () => void, options?: CollectorOptions);
+    start(): void;
+    destroy(): void;
+    updateSession(session: CustomerInteractionSession): boolean;
+    enqueue(draft: ScenarioInteractionDraft): string | null;
+    getQueueSnapshot(): readonly ScenarioInteractionObservation[];
+    isSendingEnabled(): boolean;
+    getPrincipalSessionId(): string;
+    flush(options?: {
+        keepalive?: boolean;
+    }): Promise<void>;
+    private readonly onOnlineOrFocus;
+    private readonly onVisibilityChange;
+    private readonly onPageHide;
+    private buildObservation;
+    private buildDetails;
+    private ensureCapabilities;
+    private loadCapabilities;
+    private flushOnce;
+    private selectBatch;
+    private dropUnsupportedObservations;
+    private isSupported;
+    private sessionNeedsRenewal;
+    private isCurrentGeneration;
+    private nextSequence;
+    private abortPendingRequests;
+    private createRequestControl;
+    private finishRequestControl;
+    private handleUnauthorized;
+    private scheduleFlush;
+    private scheduleRetry;
+    private scheduleCapabilityRetry;
+    private clearFlushTimer;
+    private clearTimers;
+    private clearRetryTimer;
+    private clearCapabilityRetryTimer;
+    private retryDelay;
+    private disableSending;
+    private admitWithinSessionQuota;
+    private isQuotaBlocked;
+}
+export {};

package/dist/domain/scenario-interaction/ScenarioInteractionRuntime.d.ts

@@ -0,0 +1,28 @@
+import type { CustomerInteractionSession } from "@/types";
+import { ScenarioInteractionCollector } from "./ScenarioInteractionCollector";
+import type { EngagementSubject, PresentationSubject, SurfaceState, SurfaceTransition, SurfaceTransitionContext } from "./scenario-interaction.types";
+type RuntimeOptions = ConstructorParameters<typeof ScenarioInteractionCollector>[2];
+export declare class ScenarioInteractionRuntime {
+    readonly collector: ScenarioInteractionCollector;
+    private readonly surfaceController;
+    private readonly presented;
+    private readonly engaged;
+    constructor(getSession: () => CustomerInteractionSession, onSessionExpired: () => void, options?: RuntimeOptions);
+    start(): void;
+    destroy(): void;
+    updateSession(session: CustomerInteractionSession): void;
+    transitionSurface(nextState: SurfaceState, context: SurfaceTransitionContext): SurfaceTransition;
+    getSurfaceState(): SurfaceState;
+    getSurfaceEpisodeId(): string | null;
+    getPrincipalSessionId(): string;
+    recordPresented(subject: PresentationSubject, expectedEpisodeId?: string | null): boolean;
+    recordEngagement(subject: EngagementSubject): boolean;
+    recordTargetPresented(commandId: string, surfaceEpisodeId?: string | null): boolean;
+    recordTargetActivation(commandId: string, surfaceEpisodeId?: string | null): boolean;
+    observeHighlightedTarget(input: {
+        element: Element;
+        commandId: string;
+    }): () => void;
+    private markCurrentTargetContext;
+}
+export {};

package/dist/domain/scenario-interaction/SurfaceController.d.ts

@@ -0,0 +1,13 @@
+import type { ScenarioInteractionDraft, SurfaceState, SurfaceTransition, SurfaceTransitionContext } from "./scenario-interaction.types";
+export declare class SurfaceController {
+    private readonly observe;
+    private readonly createId;
+    private state;
+    private episode;
+    constructor(observe: (draft: ScenarioInteractionDraft) => void, createId?: () => string);
+    transition(nextState: SurfaceState, context: SurfaceTransitionContext): SurfaceTransition;
+    getState(): SurfaceState;
+    getEpisodeId(): string | null;
+    markScenarioContext(attributionHandle: string): void;
+    replacePrincipal(): void;
+}

package/dist/domain/scenario-interaction/presentation-observer.d.ts

@@ -0,0 +1,12 @@
+export declare const PRESENTATION_INTERSECTION_RATIO = 0.5;
+export declare const PRESENTATION_DWELL_MS = 500;
+type PresentationObserverInput = {
+    element: Element;
+    isActive: () => boolean;
+    isPresentable?: () => boolean;
+    onPresented: () => void;
+    intersectionRatio?: number;
+    dwellMs?: number;
+};
+export declare const observePresentedElement: ({ element, isActive, isPresentable, onPresented, intersectionRatio, dwellMs, }: PresentationObserverInput) => (() => void);
+export {};

package/dist/domain/scenario-interaction/scenario-interaction.context.d.ts

@@ -0,0 +1,7 @@
+import type { ScenarioInteractionRuntime } from "./ScenarioInteractionRuntime";
+export type ScenarioInteractionContextValue = {
+    open: boolean;
+    surfaceEpisodeId: string | null;
+    runtime: ScenarioInteractionRuntime;
+};
+export declare const ScenarioInteractionContext: import("react").Context<ScenarioInteractionContextValue | null>;

package/dist/domain/scenario-interaction/scenario-interaction.types.d.ts

@@ -0,0 +1,84 @@
+export declare const SCENARIO_INTERACTION_VERSION: 1;
+export declare const SCENARIO_INTERACTION_KINDS: readonly ["SURFACE_STATE_CHANGED", "EXPERIENCE_PRESENTED", "EXPERIENCE_ENGAGED"];
+export declare const SCENARIO_INTERACTION_TYPES: readonly ["CHAT_OPENED", "CHAT_CLOSED", "MESSAGE_PRESENTED", "CHOICE_PRESENTED", "CTA_PRESENTED", "CTA_CLICKED", "CTA_DISMISSED", "TARGET_PRESENTED", "TARGET_ACTIVATED"];
+export declare const SCENARIO_INTERACTION_ACTORS: readonly ["USER", "SCENARIO", "HOST"];
+export declare const SCENARIO_INTERACTION_SUBJECT_KINDS: readonly ["SURFACE", "MESSAGE", "CHOICE", "CTA", "TARGET"];
+export declare const SCENARIO_INTERACTION_RESULTS: readonly ["SUCCEEDED", "FAILED"];
+export declare const SCENARIO_INTERACTION_REASONS: readonly ["USER_LAUNCHER", "USER_CLOSE_BUTTON", "HOST_SET_OPEN", "SCENARIO_COMMAND", "UNKNOWN"];
+export type ScenarioInteractionKind = (typeof SCENARIO_INTERACTION_KINDS)[number];
+export type ScenarioInteractionType = (typeof SCENARIO_INTERACTION_TYPES)[number];
+export type ScenarioInteractionActor = (typeof SCENARIO_INTERACTION_ACTORS)[number];
+export type ScenarioInteractionSubjectKind = (typeof SCENARIO_INTERACTION_SUBJECT_KINDS)[number];
+export type ScenarioInteractionResult = (typeof SCENARIO_INTERACTION_RESULTS)[number];
+export type ScenarioInteractionReason = (typeof SCENARIO_INTERACTION_REASONS)[number];
+export type ScenarioInteractionDetails = {
+    presentationOrdinal?: number;
+};
+export type ScenarioInteractionObservation = {
+    clientObservationId: string;
+    version: typeof SCENARIO_INTERACTION_VERSION;
+    kind: ScenarioInteractionKind;
+    type: ScenarioInteractionType;
+    actor: ScenarioInteractionActor;
+    occurredAt: string;
+    sequence: number;
+    surfaceEpisodeId?: string;
+    subjectKind?: ScenarioInteractionSubjectKind;
+    subjectId?: string;
+    result?: ScenarioInteractionResult;
+    reason?: ScenarioInteractionReason;
+    attributionHandle?: string;
+    details?: ScenarioInteractionDetails;
+};
+export type ScenarioInteractionDraft = Omit<ScenarioInteractionObservation, "clientObservationId" | "version" | "occurredAt" | "sequence">;
+export type ScenarioInteractionCapabilities = {
+    version: number;
+    maxBatchItems: number;
+    maxRequestBytes: number;
+    sessionHourlyLimit: number;
+    retentionDays: number;
+    kinds: readonly ScenarioInteractionKind[];
+    types: readonly ScenarioInteractionType[];
+    actors: readonly ScenarioInteractionActor[];
+    attributionHandleSupported: boolean;
+};
+export type ScenarioInteractionReceipt = {
+    clientObservationId: string;
+    status: "ACCEPTED" | "DUPLICATE" | "IGNORED_NO_INTEREST" | "REJECTED";
+    code?: string | null;
+    observationId?: string | null;
+    runId?: string | null;
+};
+export type ScenarioInteractionBatchResponse = {
+    receipts: ScenarioInteractionReceipt[];
+};
+export type SurfaceState = "OPEN" | "CLOSED";
+export type SurfaceTransitionActor = ScenarioInteractionActor | "SYSTEM";
+/** Exact SDK-local reasons; state-changing reasons are preserved on the wire. */
+export type SurfaceTransitionReason = "USER_LAUNCHER" | "USER_CLOSE_BUTTON" | "VOICE_SWITCH_TO_TEXT" | "HOST_SET_OPEN" | "SCENARIO_COMMAND" | "SYSTEM_RESTORE";
+export type SurfaceTransitionContext = {
+    actor: SurfaceTransitionActor;
+    reason: SurfaceTransitionReason;
+    sourceCommandId?: string;
+};
+export type SurfaceTransition = {
+    changed: boolean;
+    from: SurfaceState;
+    to: SurfaceState;
+    episodeId: string | null;
+    context: SurfaceTransitionContext;
+};
+export type PresentationSubject = {
+    subjectKind: Extract<ScenarioInteractionSubjectKind, "MESSAGE" | "CHOICE" | "CTA" | "TARGET">;
+    subjectId: string;
+    actor?: ScenarioInteractionActor;
+    attributionHandle?: string;
+    presentationOrdinal?: number;
+};
+export type EngagementSubject = {
+    type: Extract<ScenarioInteractionType, "CTA_CLICKED" | "CTA_DISMISSED" | "TARGET_ACTIVATED">;
+    subjectKind: Extract<ScenarioInteractionSubjectKind, "CTA" | "TARGET">;
+    subjectId: string;
+    attributionHandle?: string;
+    result?: ScenarioInteractionResult;
+};

package/dist/domain/scenario-interaction/useScenarioPresentation.d.ts

@@ -0,0 +1,4 @@
+import { type RefObject } from "react";
+import type { PresentationSubject } from "./scenario-interaction.types";
+import type { ScenarioInteractionRuntime } from "./ScenarioInteractionRuntime";
+export declare const useScenarioPresentation: (runtime: ScenarioInteractionRuntime | undefined, ref: RefObject<Element | null>, active: boolean, episodeId: string | null, subject: PresentationSubject | null, isPresentable?: () => boolean) => void;