@customer-agent/sdk 0.5.6-test.g260612164307

package/types/ui/WidgetComposer.d.ts

@@ -0,0 +1,40 @@
+import { ReactNode, Ref } from 'react';
+export type WidgetComposerRootProps = {
+    children: ReactNode;
+    className?: string;
+    isHidden?: boolean;
+    onSubmit?(): void;
+};
+export type WidgetComposerInputProps = {
+    inputAriaLabel: string;
+    inputRef?: Ref<HTMLTextAreaElement>;
+    placeholder: string;
+};
+export declare function WidgetComposerAttachments({ removeAttachmentLabel }: {
+    removeAttachmentLabel?: string;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function WidgetComposerRoot({ children, className, isHidden, onSubmit }: WidgetComposerRootProps): import("react/jsx-runtime").JSX.Element;
+export declare function WidgetComposerInput({ inputAriaLabel, inputRef, placeholder }: WidgetComposerInputProps): import("react/jsx-runtime").JSX.Element;
+export declare function WidgetComposerActions({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function WidgetComposerTools({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function WidgetComposerAttachmentButton({ attachmentLabel }: {
+    attachmentLabel?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function WidgetComposerEmojiPopover({ children, hostRef, isLoading, onOpenChange, open }: {
+    children: ReactNode;
+    hostRef?: Ref<HTMLDivElement>;
+    isLoading?: boolean;
+    onOpenChange?(open: boolean): void;
+    open?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function WidgetComposerEmojiButton({ emojiLabel, emojiTitle }: {
+    emojiLabel?: string;
+    emojiTitle?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function WidgetComposerSubmit({ sendLabel }: {
+    sendLabel: string;
+}): import("react/jsx-runtime").JSX.Element;

package/types/ui/WidgetGlobalLoading.d.ts

@@ -0,0 +1,4 @@
+export declare function WidgetGlobalLoading({ className, label }: {
+    className?: string;
+    label: string;
+}): import("react/jsx-runtime").JSX.Element;

package/types/ui/WidgetPanelCloseButton.d.ts

@@ -0,0 +1,4 @@
+export declare function WidgetPanelCloseButton({ closeLabel, onClose }: {
+    closeLabel: string;
+    onClose(): void;
+}): import("react/jsx-runtime").JSX.Element;

package/types/ui/classNames.d.ts

@@ -0,0 +1 @@
+export declare function cx(...classNames: Array<false | null | string | undefined>): string;

package/types/ui/hostStyle.d.ts

@@ -0,0 +1,7 @@
+import { CurrentCustomerAgentOptions } from '../sdk/config';
+export declare const HOST_PANEL_EXPANDED_HEIGHT_OFFSET = 104;
+export declare const HOST_PANEL_EXPANDED_WIDTH = 716;
+export declare const HOST_PANEL_MAX_HEIGHT = 704;
+export declare const HOST_PANEL_SAFE_MARGIN = 20;
+export declare const HOST_PANEL_WIDTH = 460;
+export declare function createHostStyleText(_widgetId: string, options: CurrentCustomerAgentOptions): string;

package/types/ui/panel/DockNavigation.d.ts

@@ -0,0 +1,14 @@
+import { ConversationEntry, ConversationEntryPrompt } from '../registry/conversationRegistry';
+export type DockNavigationProps = {
+    activeEntryId: string;
+    entries: ConversationEntry[];
+    enableEntryIntroAnimation?: boolean;
+    invitePortalContainer?: HTMLElement | null;
+    invitePrompt?: ConversationEntryPrompt | null;
+    isInvitePromptOpen?: boolean;
+    onEntrySelect(entryId: string): void;
+    onInviteClose?(invitationId: string): void;
+    onInviteLater?(invitationId: string): void;
+    onInviteStart?(invitationId: string): void;
+};
+export declare function DockNavigation({ activeEntryId, enableEntryIntroAnimation, entries, invitePortalContainer, invitePrompt, isInvitePromptOpen, onEntrySelect, onInviteClose, onInviteLater, onInviteStart }: DockNavigationProps): import("react/jsx-runtime").JSX.Element;

package/types/ui/panel/MobileDockDrawer.d.ts

@@ -0,0 +1,13 @@
+import { ConversationEntry, ConversationEntryPrompt } from '../registry/conversationRegistry';
+export type MobileDockDrawerProps = {
+    activeEntryId: string;
+    entries: ConversationEntry[];
+    invitePrompt?: ConversationEntryPrompt | null;
+    isInvitePromptOpen?: boolean;
+    onEntrySelect(entryId: string): void;
+    onInviteClose?(invitationId: string): void;
+    onInviteLater?(invitationId: string): void;
+    onInviteStart?(invitationId: string): void;
+    onOpenChange(open: boolean): void;
+};
+export declare function MobileDockDrawer({ activeEntryId, entries, invitePrompt, isInvitePromptOpen, onEntrySelect, onInviteClose, onInviteLater, onInviteStart, onOpenChange }: MobileDockDrawerProps): import("react/jsx-runtime").JSX.Element;

package/types/ui/panel/PanelShell.d.ts

@@ -0,0 +1,26 @@
+import { CSSProperties, ReactNode } from 'react';
+import { ConversationEntry, ConversationEntryPrompt } from '../registry/conversationRegistry';
+import { WidgetRoute } from '../router/routes';
+export declare const INVITE_PROMPT_OPEN_DELAY_MS = 280;
+export type PanelShellProps = {
+    activeEntryId: string;
+    ariaLabel: string;
+    children: ReactNode;
+    entries: ConversationEntry[];
+    invitePrompt?: ConversationEntryPrompt | null;
+    interviewChat?: ReactNode;
+    isChatLoading?: boolean;
+    isExpanded: boolean;
+    isMobileDockOpen: boolean;
+    isOpen: boolean;
+    route: WidgetRoute;
+    routeTransitionKey?: number;
+    style: CSSProperties;
+    viewportMode: "desktop" | "mobile";
+    onEntrySelect(entryId: string): void;
+    onInviteClose?(invitationId: string): void;
+    onInviteLater?(invitationId: string): void;
+    onInviteStart?(invitationId: string): void;
+    onMobileDockOpenChange(open: boolean): void;
+};
+export declare function PanelShell({ activeEntryId, ariaLabel, children, entries, invitePrompt, interviewChat, isChatLoading, isExpanded, isMobileDockOpen, isOpen, route, routeTransitionKey, style, viewportMode, onEntrySelect, onInviteClose, onInviteLater, onInviteStart, onMobileDockOpenChange }: PanelShellProps): import("react/jsx-runtime").JSX.Element;

package/types/ui/panel/RouteTransition.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export type RouteTransitionProps = {
+    children: ReactNode;
+    scope: "chat" | "shell";
+    transitionKey: number | string;
+};
+export declare function RouteTransition({ children, scope, transitionKey }: RouteTransitionProps): import("react/jsx-runtime").JSX.Element;

package/types/ui/panel/agentSessionState.d.ts

@@ -0,0 +1,21 @@
+import { InterviewInvitationChoice } from '../../runtime/interview/interviewTypes';
+import { ConversationEntry, ConversationEntryPrompt } from '../registry/conversationRegistry';
+export type AgentSessionState = {
+    handledInviteChoices: Record<string, InterviewInvitationChoice>;
+    entries: ConversationEntry[];
+    invitePrompt: ConversationEntryPrompt | null;
+    isMobileDockOpen: boolean;
+};
+export declare function createInitialAgentSessionState(): AgentSessionState;
+export declare function applyDiscoveredInterviewEntry(state: AgentSessionState, entry: ConversationEntry | null, viewportMode: "desktop" | "mobile", options?: {
+    canShowPrompt?: boolean;
+}): AgentSessionState;
+export declare function applyRestoredInterviewSessionEntry(state: AgentSessionState, entry: ConversationEntry | null): AgentSessionState;
+export declare function markConversationEntrySeen(state: AgentSessionState, entryId: string): AgentSessionState;
+export declare function dismissInterviewInvite(state: AgentSessionState, invitationId: string, mode: InterviewInvitationChoice): AgentSessionState;
+export declare function replaceInviteWithInterviewSessionEntry(state: AgentSessionState, { invitationId, sessionId, subtitle, title }: {
+    invitationId: string;
+    sessionId: string;
+    subtitle?: string;
+    title: string;
+}): AgentSessionState;

package/types/ui/registry/conversationRegistry.d.ts

@@ -0,0 +1,73 @@
+import { ThreadMessageLike } from '@assistant-ui/react';
+export type ConversationKind = "interview" | "support" | (string & {});
+export declare const CONVERSATION_ENTRY_STATUS: Readonly<{
+    ACTIVE: "active";
+    AVAILABLE: "available";
+    COMPLETED: "completed";
+    ERROR: "error";
+    INVITABLE: "invitable";
+    LOCKED: "locked";
+}>;
+export type ConversationEntryStatus = (typeof CONVERSATION_ENTRY_STATUS)[keyof typeof CONVERSATION_ENTRY_STATUS];
+export type ConversationEntryPrompt = {
+    anchor: "dock";
+    body?: string;
+    campaignId: string;
+    closeLabel: string;
+    invitationId: string;
+    kind: "interview-invite";
+    laterLabel: string;
+    startLabel: string;
+};
+export type ConversationEntry = {
+    id: string;
+    kind: ConversationKind;
+    metadata?: Record<string, unknown>;
+    priority?: number;
+    prompt?: ConversationEntryPrompt;
+    status: ConversationEntryStatus;
+    subtitle?: string;
+    title: string;
+    unread?: boolean;
+};
+export type ConversationCapabilities = {
+    attachments?: boolean;
+    dismiss?: boolean;
+    emoji?: boolean;
+    transcriptDownload?: boolean;
+};
+export type ConversationState = {
+    capabilities: ConversationCapabilities;
+    entry: ConversationEntry;
+    error?: string;
+    isSending: boolean;
+    messages: ThreadMessageLike[];
+};
+export type SendInput = {
+    attachments?: Array<{
+        id: string;
+    }>;
+    text: string;
+};
+export type ConversationAdapter = {
+    close?(): Promise<void>;
+    load(): Promise<ConversationState>;
+    refresh?(): Promise<void>;
+    send(input: SendInput): Promise<void>;
+};
+export type ConversationProvider = {
+    getAdapter(entryId: string): ConversationAdapter | null;
+    listEntries(): Promise<ConversationEntry[]>;
+};
+export type ConversationRegistry = ReturnType<typeof createConversationRegistry>;
+export declare function createSupportConversationProvider({ adapter, entry }: {
+    adapter: ConversationAdapter;
+    entry: Partial<ConversationEntry> & {
+        id: string;
+    };
+}): ConversationProvider;
+export declare function createConversationRegistry(providers: ConversationProvider[]): {
+    getAdapter(entryId: string): ConversationAdapter | null;
+    getEntries(): ConversationEntry[];
+    refreshEntries(): Promise<ConversationEntry[]>;
+};

package/types/ui/router/reducer.d.ts

@@ -0,0 +1,24 @@
+import { WidgetRoute } from './routes';
+export type WidgetRouterState = {
+    action: "back" | "push" | "replace" | "reset";
+    current: WidgetRoute;
+    previous?: WidgetRoute;
+    stack: WidgetRoute[];
+    transitionKey: number;
+};
+export type WidgetRouterAction = {
+    route: WidgetRoute;
+    type: "push";
+} | {
+    route: WidgetRoute;
+    type: "replace";
+} | {
+    fallback?: WidgetRoute;
+    type: "back";
+} | {
+    route: WidgetRoute;
+    type: "reset";
+};
+export declare function getDefaultAgentsConversationsRoute(): WidgetRoute;
+export declare function createInitialWidgetRouterState(): WidgetRouterState;
+export declare function widgetRouterReducer(state: WidgetRouterState, action: WidgetRouterAction): WidgetRouterState;

package/types/ui/router/routeNames.d.ts

@@ -0,0 +1,9 @@
+export declare const WIDGET_ROUTE_NAMES: {
+    readonly AGENTS_CONVERSATIONS: "agents.conversations";
+    readonly GLOBAL_ERROR: "global.error";
+    readonly GLOBAL_LOADING: "global.loading";
+};
+export declare const WIDGET_ROUTE_CHILD_NAMES: {
+    readonly CHAT: "chat";
+    readonly INTERVIEW_STARTING: "interview.starting";
+};

package/types/ui/router/routeStorage.d.ts

@@ -0,0 +1,6 @@
+import { WidgetOptions } from '../../types';
+import { WidgetRoute } from './routes';
+export declare function getWidgetRouteStorageKey(options: WidgetOptions): string;
+export declare function isPersistableWidgetRoute(route: WidgetRoute): boolean;
+export declare function readStoredWidgetRoute(options: WidgetOptions): WidgetRoute | null;
+export declare function writeStoredWidgetRoute(options: WidgetOptions, route: WidgetRoute): void;

package/types/ui/router/routes.d.ts

@@ -0,0 +1,32 @@
+import { WIDGET_ROUTE_CHILD_NAMES, WIDGET_ROUTE_NAMES } from './routeNames';
+export type AgentsConversationsRoute = {
+    entryId: string;
+    name: typeof WIDGET_ROUTE_CHILD_NAMES.CHAT;
+} | {
+    entryId: string;
+    invitationId: string;
+    name: typeof WIDGET_ROUTE_CHILD_NAMES.INTERVIEW_STARTING;
+};
+export type WidgetRoute = {
+    name: typeof WIDGET_ROUTE_NAMES.GLOBAL_LOADING;
+    target?: AgentsConversationsWidgetRoute;
+} | {
+    name: typeof WIDGET_ROUTE_NAMES.GLOBAL_ERROR;
+    retryTo?: WidgetRoute;
+} | AgentsConversationsWidgetRoute;
+export type AgentsConversationsWidgetRoute = {
+    child: AgentsConversationsRoute;
+    name: typeof WIDGET_ROUTE_NAMES.AGENTS_CONVERSATIONS;
+};
+export type InterviewSessionWidgetRoute = AgentsConversationsWidgetRoute & {
+    child: AgentsConversationsRoute & {
+        entryId: `interview/session/${string}`;
+    };
+};
+export declare function isInterviewSessionEntryId(entryId: string): boolean;
+export declare function createSupportSessionEntryId(conversationId: string): `support/session/${string}`;
+export declare function isSupportSessionEntryId(entryId: string): boolean;
+export declare function isSupportEntryId(entryId: string): boolean;
+export declare function getSupportConversationIdFromEntryId(entryId: string): string | null;
+export declare function isInterviewSessionRoute(route: WidgetRoute | null | undefined): route is InterviewSessionWidgetRoute;
+export declare function createChatRoute(entryId: string): AgentsConversationsWidgetRoute;

package/types/ui/router/targetRoute.d.ts

@@ -0,0 +1,3 @@
+import { CustomerAgentTarget } from '../../sdk/public-types';
+import { WidgetRoute } from './routes';
+export declare function getRouteForCustomerAgentTarget(target: CustomerAgentTarget): WidgetRoute;

package/types/ui/screens/interview/InterviewChatScreen.d.ts

@@ -0,0 +1,18 @@
+import { CustomerAgentEventBus } from '../../../sdk/events';
+import { ResolvedWidgetLocale } from '../../../sdk/i18n';
+import { InterviewSessionController } from './interviewSessionController';
+export declare function InterviewChatScreen({ controller, eventBus, locale, description, isExpanded, isOpen, onDownloadTranscript, onOpenMobileDock, onToggleExpanded, title, transcriptAppName, visitorName, viewportMode }: {
+    controller: InterviewSessionController;
+    description?: string;
+    eventBus?: CustomerAgentEventBus;
+    isExpanded?: boolean;
+    isOpen?: boolean;
+    locale: ResolvedWidgetLocale;
+    onDownloadTranscript?(): void;
+    onOpenMobileDock?(): void;
+    onToggleExpanded?(): void;
+    title: string;
+    transcriptAppName?: string;
+    visitorName?: string;
+    viewportMode?: "desktop" | "mobile";
+}): import("react/jsx-runtime").JSX.Element;

package/types/ui/screens/interview/InterviewInvitePrompt.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { ConversationEntryPrompt } from '../../registry/conversationRegistry';
+export type InterviewInvitePromptProps = {
+    children: ReactNode;
+    isOpen: boolean;
+    portalContainer?: HTMLElement | null;
+    prompt: ConversationEntryPrompt;
+    title: string;
+    onClose(invitationId: string): void;
+    onLater(invitationId: string): void;
+    onStart(invitationId: string): void;
+};
+export declare function InterviewInvitePrompt({ children, isOpen, portalContainer, prompt, title, onClose, onLater, onStart }: InterviewInvitePromptProps): import("react/jsx-runtime").JSX.Element;

package/types/ui/screens/interview/interviewSessionCache.d.ts

@@ -0,0 +1,10 @@
+import { WidgetOptions } from '../../../types';
+export type CachedInterviewSession = {
+    entryId: string;
+    priority: number;
+    sessionId: string;
+    title: string;
+};
+export declare function readCachedInterviewSession(options: WidgetOptions): CachedInterviewSession | null;
+export declare function writeCachedInterviewSession(options: WidgetOptions, session: CachedInterviewSession): void;
+export declare function clearCachedInterviewSession(options: WidgetOptions): void;

package/types/ui/screens/interview/interviewSessionController.d.ts

@@ -0,0 +1,89 @@
+import { ThreadMessageLike } from '@assistant-ui/react';
+import { CUSTOMER_AGENT_INTERVIEW_STATUS, InterviewInvitationChoice, InterviewSessionResponse, InterviewStatus } from '../../../runtime/interview/interviewTypes';
+import { ConversationContextPayload } from '../../../sdk/conversation';
+import { WidgetOptions } from '../../../types';
+import { ConversationEntry } from '../../registry/conversationRegistry';
+type InvitationCard = {
+    body: string;
+    laterCta: string;
+    startCta: string;
+    title: string;
+};
+type EligibilityResponse = {
+    eligible: false;
+    status?: string;
+} | {
+    campaignId: string;
+    eligible: true;
+    invitation: InvitationCard;
+    showRequestId: string;
+    status?: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.AVAILABLE | string;
+    variantKey?: string | null;
+};
+export type InterviewClient = {
+    checkEligibility(payload: Record<string, unknown>): Promise<EligibilityResponse>;
+    chooseInvitation(id: string, payload: {
+        choice: InterviewInvitationChoice;
+    }): Promise<void>;
+    createInvitation(payload: Record<string, unknown>): Promise<{
+        invitationId: string;
+    }>;
+    getReward(sessionId: string): Promise<unknown>;
+    getSession(sessionId: string): Promise<InterviewSessionResponse>;
+    sendMessage(sessionId: string, payload: {
+        clientMessageId: string;
+        content: string;
+        locale?: string;
+    }): Promise<{
+        assistantMessage: string;
+        completion?: {
+            reason: string;
+        };
+        duplicate?: true;
+        sessionStatus: InterviewStatus;
+    }>;
+    startInvitation(id: string, payload: ConversationContextPayload): Promise<InterviewSessionResponse>;
+};
+export declare const INTERVIEW_SESSION_PHASE: Readonly<{
+    ACTIVE: "active";
+    ERROR: "error";
+    IDLE: "idle";
+    LOADING: "loading";
+    SENDING: "sending";
+    TERMINAL: "terminal";
+}>;
+export type InterviewSessionPhase = (typeof INTERVIEW_SESSION_PHASE)[keyof typeof INTERVIEW_SESSION_PHASE];
+export type InterviewSessionState = {
+    completion?: {
+        reason: string;
+    };
+    messages: ThreadMessageLike[];
+    phase: InterviewSessionPhase;
+    reward?: InterviewSessionReward | null;
+    sessionId?: string;
+    status?: InterviewStatus;
+};
+export type InterviewSessionController = ReturnType<typeof createInterviewSessionController>;
+export type InterviewSessionReward = {
+    amount?: unknown;
+    currency?: unknown;
+    status?: unknown;
+};
+export declare function createInterviewSessionController({ client, options }: {
+    client: InterviewClient;
+    options: WidgetOptions;
+}): {
+    chooseInvitation(invitationId: string, choice: InterviewInvitationChoice): Promise<void>;
+    discoverInvitation(): Promise<ConversationEntry | null>;
+    getState(): InterviewSessionState;
+    hydrateSession(session: InterviewSessionResponse): void;
+    loadReward(sessionId: string): Promise<InterviewSessionReward | null>;
+    sendMessage(content: string): Promise<void>;
+    startInvitation(invitationId: string): Promise<{
+        entryId: string;
+        sessionId: string;
+    }>;
+    restoreCachedSession(): Promise<ConversationEntry | null>;
+    subscribe(listener: (state: InterviewSessionState) => void): () => void;
+};
+export {};

package/types/ui/screens/interview/interviewUiAdapter.d.ts

@@ -0,0 +1,3 @@
+import { CustomerAgentInterviewState } from '../../../sdk/public-types';
+import { ConversationEntry } from '../../registry/conversationRegistry';
+export declare function createInterviewEntryFromRuntimeState(interview: CustomerAgentInterviewState): ConversationEntry | null;

package/types/ui/screens/interview/interviewWidgetClient.d.ts

@@ -0,0 +1,2 @@
+import { InterviewClient } from './interviewSessionController';
+export declare function createInterviewWidgetClient(): InterviewClient;

package/types/ui/transcript.d.ts

@@ -0,0 +1,17 @@
+import { WidgetOptions } from '../types';
+export type TranscriptMessage = {
+    createdAt: Date;
+    role: "assistant" | "user";
+    speaker?: string;
+    text: string;
+};
+export declare function getTranscriptVisitorName(options?: Partial<WidgetOptions> | null): string;
+export declare function buildIntercomStyleTranscript({ conversationName, exportedAt, exportSourceName, locale, messages, startedAt, userSpeaker }: {
+    conversationName: string;
+    exportedAt: Date;
+    exportSourceName?: string;
+    locale: string;
+    messages: readonly TranscriptMessage[];
+    startedAt?: Date;
+    userSpeaker?: string;
+}): string;

package/types/ui/useWidgetEmojiPicker.d.ts

@@ -0,0 +1,20 @@
+import { ThreadComposerRuntime } from '@assistant-ui/react';
+import { RefObject } from 'react';
+export declare function resolveEmojiPickerDataSourceUrl({ bundledDataSourceUrl, isDev, moduleUrl, pageUrl, sdkFormat }: {
+    bundledDataSourceUrl?: string;
+    isDev: boolean;
+    moduleUrl: string | undefined;
+    pageUrl: string;
+    sdkFormat: string | undefined;
+}): string;
+export declare function useWidgetEmojiPicker({ composerRuntime, inputRef, shouldSuppressComposerFocus }: {
+    composerRuntime: ThreadComposerRuntime;
+    inputRef: RefObject<HTMLTextAreaElement | null>;
+    shouldSuppressComposerFocus?: boolean;
+}): {
+    closeEmojiPicker(): void;
+    emojiPickerHostRef: import('react').Dispatch<import('react').SetStateAction<HTMLDivElement | null>>;
+    isEmojiPickerLoading: boolean;
+    isEmojiPickerOpen: boolean;
+    onEmojiOpenChange(nextIsOpen: boolean): void;
+};