@brainfish-ai/components 0.35.19 → 0.36.0

package/dist/components/chat-search/types.d.ts

@@ -0,0 +1,388 @@
+import { JSONSchemaType } from 'ajv';
+import { ReactNode, CSSProperties } from 'react';
+import { FeatureFlags } from '../../lib/feature-flags';
+export type JSONSchema<T> = JSONSchemaType<T>;
+export interface TextConfig {
+    headerText?: string;
+    searchPlaceholder?: string;
+    attachImageText?: string;
+    allDocumentsText?: string;
+    loadingSearchText?: string;
+    loadingAnswerText?: string;
+    errorText?: string;
+    followUpPlaceholder?: string;
+    positiveAnswerText?: string;
+    negativeAnswerText?: string;
+    suggestionsTitle?: string;
+    uncertaintyFallbackText?: Record<string, string>;
+}
+export declare enum ActionType {
+    CallPhone = "call_phone",
+    OpenUrl = "open_url",
+    SendEmail = "send_email",
+    RunCallback = "run_callback",
+    LaunchIntercomChat = "launch_intercom_chat",
+    LaunchZendeskChat = "launch_zendesk_chat",
+    LaunchZendeskMessenger = "launch_zendesk_messenger",
+    LaunchFreshdesk = "launch_freshdesk",
+    LaunchSupportTicketForm = "launch_support_ticket_form",
+    LaunchZendeskSunshineChat = "launch_zendesk_sunshine_chat",
+    LaunchWebhookHandoff = "launch_webhook_handoff"
+}
+export type FeedbackResponse = 'accept' | 'reject';
+export type APIFeedbackResponse = 'positive' | 'negative';
+/**
+ * Defines a URL redirect rule with pattern matching
+ * @example { source: '/knowledge/:id/:path', destination: '/knowledge/test/:path' }
+ */
+export type RedirectRule = {
+    source: string;
+    destination: string;
+};
+export type MarkdownTextBlock = {
+    id: string;
+    type: 'markdown-text';
+    text: string;
+};
+export type ActionButtonsBlock = {
+    id: string;
+    type: 'action-buttons';
+};
+export type ActionInputFormBlock = {
+    id: string;
+    type: 'action-input-form';
+    state: 'ready' | 'processing' | 'completed';
+    actionId: string;
+    initialValues: ActionInputs;
+    schema: ActionInputsSchema;
+    onSubmit?: (inputs: ActionInputs) => void;
+    inputs: ActionInput[];
+};
+export type ActionInput = {
+    name: string;
+    required: boolean;
+    schema: {
+        type: string;
+        title: string;
+        description: string;
+        oneOf?: {
+            const: string;
+            title: string;
+        }[];
+    };
+    type: string;
+    ui: {
+        type: string;
+    };
+};
+export type AnswerBlock = MarkdownTextBlock | ActionButtonsBlock | ActionInputFormBlock;
+export type CreateAnswerBlock = Omit<MarkdownTextBlock, 'id'> | Omit<ActionButtonsBlock, 'id'> | Omit<ActionInputFormBlock, 'id'>;
+export type AnswerState = 'fetching-search-results' | 'fetching-stream' | 'streaming' | 'getting-action-inputs' | 'awaiting-knowledge-group' | 'completed';
+export type ConversationMessage = {
+    question: string;
+    answer: string;
+};
+export type ConversationContext = {
+    conversationId?: string;
+    messages: ConversationMessage[];
+};
+export type ActionClick = {
+    action: NextBestAction;
+    searchQueryId: string;
+    query: string;
+    answer: string;
+    success?: boolean;
+};
+export type Action = {
+    id: string;
+    type: ActionType;
+    action: {
+        version: string;
+        options: {
+            title?: string;
+            [key: string]: any;
+        };
+    };
+};
+export interface AnswerAttachment {
+    type: AttachmentType;
+    url: string;
+    filename?: string;
+}
+export interface Answer {
+    id: string;
+    state: AnswerState;
+    question: string;
+    blocks: AnswerBlock[];
+    searchResults?: SearchResult[];
+    followUpQuestions?: string[];
+    searchQueryId?: string;
+    feedback?: FeedbackResponse;
+    isUncertain?: boolean;
+    uncertaintyLanguage?: string | null;
+    uncertaintyFallbackText?: string;
+    searchIntentId?: string;
+    actions?: Action[];
+    hasError?: boolean;
+    attachments?: AnswerAttachment[];
+    statusMessage?: string;
+}
+export type ActionInputValue = string | number | boolean | null;
+export type ActionInputs = Record<string, ActionInputValue>;
+export type ActionInputsSchema = JSONSchemaType<ActionInputs>;
+export type AnswerStreamRequest = {
+    type: 'generate-for-query';
+    searchQueryId: string;
+    conversationId?: string;
+    profileId?: string;
+    context?: {
+        type: 'text';
+        text: string;
+    }[];
+    attachments?: {
+        type: AttachmentType;
+        url: string;
+        filename?: string;
+    }[];
+    parameters?: ActionInputs;
+} | {
+    type: 'invoke-action';
+    searchIntentId: string;
+    actionId: string;
+    parameters: ActionInputs;
+    conversationId?: string;
+    profileId?: string;
+} | {
+    type: 'client-execution-result';
+    searchIntentId: string;
+    actionId: string;
+    results: ClientExecutionResult;
+    conversationId?: string;
+    searchQueryId: string;
+    profileId?: string;
+};
+export type ClientExecutionResult = {
+    success: boolean;
+    data?: Record<string, any>;
+    reason?: string;
+};
+export interface SearchResult {
+    id: string;
+    title: string;
+    url: string;
+}
+export interface SearchResponse {
+    results: SearchResult[];
+    searchQueryId: string;
+    isAgenticResponse?: boolean;
+}
+export interface FollowUpQuestionsResponse {
+    questions: string[];
+}
+export interface Collection {
+    id: string;
+    name: string;
+    siteEnabled?: boolean;
+}
+export interface KnowledgeSourceGroup {
+    id: string;
+    name: string;
+    collectionIds: string[];
+}
+export interface Suggestion {
+    id: string;
+    question: string;
+    conversationId?: string;
+    messageCount?: number;
+}
+export type AttachmentType = 'image' | 'file';
+export type AttachedFile = {
+    id: string;
+    file: File;
+    preview: string;
+    status: 'uploading' | 'uploaded';
+    publicUrl?: string;
+    attachmentType: AttachmentType;
+};
+export interface ChatSearchProps {
+    suggestions?: Suggestion[];
+    collections?: Array<Collection>;
+    selectedCollectionId?: string;
+    onCollectionChange?: (collectionId: string) => void;
+    selectedRegion?: string;
+    onRegionChange?: (region: string) => void;
+    apiKey?: string;
+    fetchRegionConfig?: (apiKey: string, region: string) => Promise<{
+        settings?: {
+            collections?: Collection[];
+        };
+    } | null>;
+    searchEndpoint: string;
+    answerEndpoint: string;
+    answerStreamEndpoint: string;
+    uploadEndpoint?: string;
+    feedbackEndpoint?: string;
+    feedbackReasonEndpoint?: string;
+    loadConversationEndpoint?: string;
+    conversationHistoryEndpoint?: string;
+    markConversationReadEndpoint?: string;
+    markConversationCompletedEndpoint?: string;
+    reconnectHandoff?: (conversationId: string) => void;
+    resetHandoff?: () => void;
+    followUpQuestionsEndpoint?: string;
+    autocompleteEndpoint?: string;
+    contentTypeEndpoint?: string;
+    disableFollowUpQuestions?: boolean;
+    enableFileAttachment?: boolean;
+    disableFeedback?: boolean;
+    disclaimer?: string;
+    offset?: number;
+    headers?: Record<string, string>;
+    textConfig?: TextConfig;
+    searchPath?: string;
+    className?: string;
+    onToggleSizeButtonClick?: () => void;
+    trackEvent?: (eventName: string, data?: Record<string, any>) => void;
+    featureFlags?: FeatureFlags;
+    onCloseWidget?: () => void;
+    isWidgetMode?: boolean;
+    nextBestActions?: NextBestAction[];
+    bodyActionButtons?: NextBestAction[];
+    onNextBestActionClick?: ({ action, searchQueryId, query, answer, conversation, }: {
+        action: NextBestAction;
+        searchQueryId: string;
+        query: string;
+        answer: string;
+        conversation?: ConversationContext;
+    }) => void;
+    userData?: Record<string, unknown> | null;
+    redirectRules?: RedirectRule[];
+    secretAttributes?: string;
+    allowedRegions?: string[];
+    style?: CSSProperties;
+    isAgentAssist?: boolean;
+    isSearchWidget?: boolean;
+    hideCitations?: boolean;
+    conversationInlineSlot?: ReactNode;
+    liveHumanAgentChatSlot?: ReactNode;
+    botAvatarUrl?: string;
+    favicon?: string;
+    initialAiMessage?: string;
+    knowledgeSourceGroups?: KnowledgeSourceGroup[];
+}
+export interface ChatSearchState {
+    showResults: boolean;
+    answers: Answer[];
+    isLoading: boolean;
+    error?: string;
+}
+type TextChunk = {
+    type: 'answer-text-chunk';
+    content: string;
+};
+type GetActionInputs = {
+    type: 'get-action-inputs';
+    schema: ActionInputsSchema;
+    values: Record<string, string | number | boolean | null>;
+    searchIntentId: string;
+    actionId: string;
+    inputs: ActionInput[];
+    actionType: string;
+    actionKey: string;
+};
+export type ActionButtons = {
+    type: 'action-buttons';
+    actions: Array<{
+        id: string;
+        type: string;
+        action: {
+            version: string;
+            options: {
+                title?: string;
+                phoneNumber?: string;
+                to?: string;
+                [key: string]: any;
+            };
+        };
+    }>;
+    searchIntentId: string;
+};
+export type Citations = {
+    type: 'citations';
+    data: SearchResult[];
+};
+type AnswerError = {
+    type: 'answer-error';
+    message: string;
+};
+export type StatusMessage = {
+    type: 'status-message';
+    message: string;
+};
+export type AnswerStreamEvent = TextChunk | GetActionInputs | ActionButtons | Citations | AnswerError | StatusMessage;
+type UrlString = string & {
+    __url: never;
+};
+export declare const validateUrlString: (value: string) => UrlString;
+export declare enum NextBestActionType {
+    Link = "link",
+    Email = "email",
+    Phone = "phone",
+    Callback = "callback",
+    Function = "function",
+    ZendeskChat = "zendesk_chat",
+    ZendeskMessenger = "zendesk_messenger",
+    IntercomChat = "intercom_chat",
+    Freshdesk = "freshdesk",
+    ZendeskSunshineChat = "zendesk_sunshine_chat",
+    WebhookHandoff = "webhook_handoff"
+}
+export type NextBestActionValue = {
+    link: UrlString;
+    email: string;
+    phone: string;
+    callback: string;
+    function: string;
+    zendesk_chat: string;
+    zendesk_messenger: string;
+    intercom_chat: string;
+    freshdesk: string;
+    zendesk_sunshine_chat: string;
+    webhook_handoff: string;
+};
+export type NextBestAction = {
+    id?: string;
+    label: string;
+    type: NextBestActionType;
+    icon?: string | UrlString;
+    value: NextBestActionValue[NextBestActionType];
+};
+export type SearchQueryAttribute = string | number | boolean | null;
+export type SearchQueryAttributes = Record<string, SearchQueryAttribute>;
+export type ConversationSummary = {
+    conversationId: string;
+    title: string;
+    status: 'active' | 'completed';
+    subtitle?: string;
+    timestamp: string;
+    isHandoff: boolean;
+    agentAvatarUrl?: string | null;
+    hasUnread?: boolean;
+};
+export interface ConversationHistoryAPIItem {
+    conversationId: string;
+    title: string;
+    status: 'active' | 'completed';
+    lastActivityAt: string;
+    createdAt: string;
+    isHandoff: boolean;
+    messageCount: number;
+    agentName?: string | null;
+    agentAvatarUrl?: string | null;
+    hasUnread?: boolean;
+}
+export interface ConversationHistoryResponse {
+    success: boolean;
+    data: ConversationHistoryAPIItem[];
+}
+export {};

package/dist/{combobox.d.ts → components/combobox/combobox.d.ts}

@@ -1,49 +1,43 @@
-import * as React_2 from 'react';
-
-export declare function Combobox<T extends ComboboxItem = ComboboxItem>({ options, defaultValueLabel, placeholder, noResultsLabel, className, onOpenChange, onChange, dropdownWidth, value: controlledValue, disabled, renderItem, renderValue, renderTrigger, appendToBody, }: ComboboxProps<T>): React_2.JSX.Element;
-
-export declare interface ComboboxItem {
-    value: string;
-    label: string;
-    icon?: React_2.ReactNode;
-    /** Additional data that can be passed to custom renderers */
-    data?: any;
-}
-
-export declare interface ComboboxProps<T extends ComboboxItem = ComboboxItem> {
-    options: T[];
-    defaultValueLabel: string;
-    placeholder: string;
-    noResultsLabel: string;
-    className?: string;
-    dropdownWidth?: number;
-    value?: string;
-    /** Whether the combobox is disabled */
-    disabled?: boolean;
-    /** Callback on open state change */
-    onOpenChange?: (open: boolean) => void;
-    /** Callback on value change */
-    onChange?: (value: string) => void;
-    /** Custom render function for each item in the dropdown */
-    renderItem?: (props: ComboboxRenderItemProps<T>) => React_2.ReactNode;
-    /** Custom render function for the selected value in the trigger button */
-    renderValue?: (item: T) => React_2.ReactNode;
-    /** Custom render function for the entire trigger button content */
-    renderTrigger?: (props: {
-        selectedItem: T | undefined;
-        isOpen: boolean;
-    }) => React_2.ReactNode;
-    /**
-     * When false, the dropdown stays in the React tree instead of portaling to body.
-     * Use inside modals/dialogs so the list is not detached from the dialog layer.
-     */
-    appendToBody?: boolean;
-}
-
-export declare interface ComboboxRenderItemProps<T extends ComboboxItem = ComboboxItem> {
-    item: T;
-    isSelected: boolean;
-    onSelect: () => void;
-}
-
-export { }
+import * as React from 'react';
+export interface ComboboxItem {
+    value: string;
+    label: string;
+    icon?: React.ReactNode;
+    /** Additional data that can be passed to custom renderers */
+    data?: any;
+}
+export interface ComboboxRenderItemProps<T extends ComboboxItem = ComboboxItem> {
+    item: T;
+    isSelected: boolean;
+    onSelect: () => void;
+}
+export interface ComboboxProps<T extends ComboboxItem = ComboboxItem> {
+    options: T[];
+    defaultValueLabel: string;
+    placeholder: string;
+    noResultsLabel: string;
+    className?: string;
+    dropdownWidth?: number;
+    value?: string;
+    /** Whether the combobox is disabled */
+    disabled?: boolean;
+    /** Callback on open state change */
+    onOpenChange?: (open: boolean) => void;
+    /** Callback on value change */
+    onChange?: (value: string) => void;
+    /** Custom render function for each item in the dropdown */
+    renderItem?: (props: ComboboxRenderItemProps<T>) => React.ReactNode;
+    /** Custom render function for the selected value in the trigger button */
+    renderValue?: (item: T) => React.ReactNode;
+    /** Custom render function for the entire trigger button content */
+    renderTrigger?: (props: {
+        selectedItem: T | undefined;
+        isOpen: boolean;
+    }) => React.ReactNode;
+    /**
+     * When false, the dropdown stays in the React tree instead of portaling to body.
+     * Use inside modals/dialogs so the list is not detached from the dialog layer.
+     */
+    appendToBody?: boolean;
+}
+export declare function Combobox<T extends ComboboxItem = ComboboxItem>({ options, defaultValueLabel, placeholder, noResultsLabel, className, onOpenChange, onChange, dropdownWidth, value: controlledValue, disabled, renderItem, renderValue, renderTrigger, appendToBody, }: ComboboxProps<T>): React.JSX.Element;

package/dist/components/combobox/index.d.ts

@@ -0,0 +1 @@
+export * from './combobox';

package/dist/components/confirm-dialog/confirm-dialog.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { AlertDialogAction } from '../ui/alert-dialog';
+interface Props {
+    title: string;
+    description: React.ReactNode;
+    onSubmit: () => Promise<void> | void;
+    onCancel?: () => void;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    variant: React.ComponentProps<typeof AlertDialogAction>['variant'];
+    cancelText: string;
+    submitText: string;
+    loadingText?: string;
+    zIndex?: number;
+}
+export interface ConfirmDialogRef {
+    open: () => void;
+    close: () => void;
+}
+export declare const ConfirmDialog: React.ForwardRefExoticComponent<Props & React.RefAttributes<ConfirmDialogRef>>;
+export {};

package/dist/components/confirm-dialog/index.d.ts

@@ -0,0 +1 @@
+export * from './confirm-dialog';

package/dist/components/conversation/AttachmentPreviews.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { FileAttachment, FileAttachmentBlock } from './types';
+interface InputImageThumbnailsProps {
+    attachments: FileAttachment[];
+    onRemove?: (attachment: FileAttachment) => void;
+    className?: string;
+}
+export declare function InputImageThumbnails({ attachments, onRemove, className }: InputImageThumbnailsProps): React.JSX.Element | null;
+interface MessageImageThumbnailsProps {
+    blocks: FileAttachmentBlock[];
+    className?: string;
+}
+export declare function MessageImageThumbnails({ blocks, className }: MessageImageThumbnailsProps): React.JSX.Element | null;
+export {};

package/dist/components/conversation/ContextPillBadge.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+import { ContextPill } from './types';
+interface ContextPillBadgeProps {
+    pill: ContextPill;
+    onRemove?: (pill: ContextPill) => void;
+}
+export declare const ContextPillBadge: ({ pill, onRemove }: ContextPillBadgeProps) => React.JSX.Element;
+export {};

package/dist/components/conversation/Conversation.d.ts

@@ -0,0 +1,45 @@
+import { default as React, ReactNode } from 'react';
+import { Message, ConversationCallbacks, Suggestion, ConversationAction, Attachment, Collection, Page } from './types';
+interface ConversationProps {
+    messages: Message[];
+    callbacks: ConversationCallbacks;
+    children?: ReactNode;
+    suggestions?: Suggestion[];
+    actions?: ConversationAction[];
+    placeholder?: string;
+    attachments?: Attachment[];
+    collections?: Collection[];
+    pages?: Page[];
+    acceptedFileTypes?: string[];
+    showBranding?: boolean;
+    className?: string;
+    showHistoryButton?: boolean;
+    headerTitle?: string;
+}
+export declare const Conversation: (({ messages, callbacks, children, suggestions, actions, placeholder, attachments, collections, pages, acceptedFileTypes, showBranding, className, showHistoryButton, headerTitle, }: ConversationProps) => React.JSX.Element) & {
+    Header: {
+        ({ className, headerTitle, showHistoryButton, showBorder, }: import('./ConversationHeader').ConversationHeaderProps): React.JSX.Element;
+        displayName: string;
+    };
+    Messages: {
+        ({ className, bottomPadding, onContentBehind, onScrolledFromTop, }: import('./ConversationMessages').ConversationMessagesProps): React.JSX.Element;
+        displayName: string;
+    };
+    Input: {
+        ({ placeholder, attachments, collections, pages, acceptedFileTypes, disabled, isElevated, className, }: import('./ConversationInput').ConversationInputProps): React.JSX.Element;
+        displayName: string;
+    };
+    Suggestions: {
+        ({ items, className }: import('./ConversationSuggestions').ConversationSuggestionsProps): React.JSX.Element | null;
+        displayName: string;
+    };
+    Actions: {
+        ({ actions, onActionClick, className }: import('./ConversationActions').ConversationActionsProps): React.JSX.Element | null;
+        displayName: string;
+    };
+    Loading: {
+        ({ className, children, variant, }: import('./ConversationStatus').ConversationStatusProps): React.JSX.Element;
+        displayName: string;
+    };
+};
+export {};

package/dist/components/conversation/ConversationActions.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { ConversationAction } from './types';
+export interface ConversationActionsProps {
+    actions: ConversationAction[];
+    onActionClick?: (action: ConversationAction) => void;
+    className?: string;
+}
+export declare const ConversationActions: {
+    ({ actions, onActionClick, className }: ConversationActionsProps): React.JSX.Element | null;
+    displayName: string;
+};

package/dist/components/conversation/ConversationContext.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { Message, ConversationCallbacks } from './types';
+export interface ConversationContextValue {
+    messages: Message[];
+    callbacks: ConversationCallbacks;
+    isStreaming: boolean;
+    reportScrolledFromTop?: (isScrolled: boolean) => void;
+}
+export declare function useConversation(): ConversationContextValue;
+interface ConversationProviderProps {
+    messages: Message[];
+    callbacks: ConversationCallbacks;
+    reportScrolledFromTop?: (isScrolled: boolean) => void;
+    children: React.ReactNode;
+}
+export declare function ConversationProvider({ messages, callbacks, reportScrolledFromTop, children, }: ConversationProviderProps): React.JSX.Element;
+export {};

package/dist/components/conversation/ConversationHeader.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+export interface ConversationHeaderProps {
+    className?: string;
+    children?: React.ReactNode;
+    headerTitle?: string;
+    showHistoryButton?: boolean;
+    showBorder?: boolean;
+}
+export declare const ConversationHeader: {
+    ({ className, headerTitle, showHistoryButton, showBorder, }: ConversationHeaderProps): React.JSX.Element;
+    displayName: string;
+};

package/dist/components/conversation/ConversationInput.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { Attachment, Collection, Page } from './types';
+export interface ConversationInputProps {
+    placeholder?: string;
+    attachments?: Attachment[];
+    collections?: Collection[];
+    pages?: Page[];
+    acceptedFileTypes?: string[];
+    disabled?: boolean;
+    isElevated?: boolean;
+    className?: string;
+}
+export declare const ConversationInput: {
+    ({ placeholder, attachments, collections, pages, acceptedFileTypes, disabled, isElevated, className, }: ConversationInputProps): React.JSX.Element;
+    displayName: string;
+};

package/dist/components/conversation/ConversationMessage.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+import { Message } from './types';
+interface ConversationMessageProps {
+    message: Message;
+    className?: string;
+}
+export declare const ConversationMessage: ({ message, className }: ConversationMessageProps) => React.JSX.Element | null;
+export {};

package/dist/components/conversation/ConversationMessageAssistant.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { Message } from './types';
+interface ConversationMessageAssistantProps {
+    message: Message;
+    className?: string;
+}
+export declare const ConversationMessageAssistant: {
+    ({ message, className }: ConversationMessageAssistantProps): React.JSX.Element;
+    displayName: string;
+};
+export {};

package/dist/components/conversation/ConversationMessageUser.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { Message } from './types';
+interface ConversationMessageUserProps {
+    message: Message;
+    className?: string;
+}
+export declare const ConversationMessageUser: {
+    ({ message, className }: ConversationMessageUserProps): React.JSX.Element;
+    displayName: string;
+};
+export {};