@apia/ai 4.0.9 → 4.0.13

package/index.ts/index.d.ts

@@ -0,0 +1,343 @@
+import * as react from 'react';
+import { ReactNode, FC, ReactElement } from 'react';
+import * as _apia_util from '@apia/util';
+import { EventEmitter, AudioRecorder } from '@apia/util';
+import { CollectorField } from '@apia/validations';
+import { FilterDTO } from '@apia/components';
+import { TActionDispatcher } from '@apia/dashboard-controller';
+
+declare const AutoscrollContainer: ({ children }: {
+    children: ReactNode;
+}) => react.JSX.Element;
+
+declare class ChatMessage {
+    message: ReactNode;
+    messageType: TMessageType;
+    attachments: IAttachment[];
+    reference: ReactNode;
+    id: number;
+    parseMessage(message: string): string;
+    constructor(message?: ReactNode, messageType?: TMessageType, attachments?: IAttachment[], reference?: ReactNode);
+    copy: () => ChatMessage;
+    Component: (() => react.JSX.Element) & {
+        displayName: string;
+    };
+}
+
+interface IAttachment {
+    Component: (props?: any) => ReactNode;
+    getId: () => string;
+}
+type TChatControllerState = {
+    isLoading: boolean;
+    isRecording: boolean;
+    canRecord: boolean;
+    canAttach: boolean;
+    canAddSystemMessage: boolean;
+    canAddUserMessage: boolean;
+    hideDeleteButton: boolean;
+    maxAttachmentsSize: number;
+    messages: ChatMessage[];
+    attachments: IAttachment[];
+    currentMessage: string;
+};
+type MessageCallback = (props: {
+    message: ChatMessage;
+    attachments: IAttachment[];
+}) => Promise<any>;
+declare class ChatController2 {
+    private onMessageSubmit;
+    id: string;
+    state: TChatControllerState;
+    constructor(props: Partial<TChatControllerState>, onMessageSubmit: MessageCallback, id: string);
+    addMessage(message: ChatMessage): void;
+    protected Header: () => react.JSX.Element;
+    protected History: () => react.JSX.Element;
+    protected Attachments: () => react.JSX.Element;
+    protected TextArea: (() => react.JSX.Element) & {
+        displayName: string;
+    };
+    Renderer: (() => react.JSX.Element) & {
+        displayName: string;
+    };
+}
+
+declare enum AIMessageRole {
+    USER = "USER",
+    SYSTEM = "SYSTEM"
+}
+interface Reactive {
+    Component: FC<any>;
+}
+
+declare class AIContent extends CollectorField implements Reactive {
+    type: string;
+    content: ReactNode;
+    constructor(content?: ReactNode);
+    Component: () => react.JSX.Element;
+}
+
+declare class AIMessageAttachments implements Reactive, IAttachment {
+    private close?;
+    role: AIMessageRole;
+    content: AIContent;
+    id: string;
+    customDescription: boolean;
+    constructor(role: AIMessageRole, content: AIContent, close?: (() => void) | undefined);
+    addDescription: () => Promise<void>;
+    getId(): string;
+    Component: (props: {
+        closeButton?: boolean;
+        canAddDescription?: boolean;
+    }) => react.JSX.Element;
+}
+
+type TMessageType = 'user' | 'system' | 'warning' | 'error' | 'information' | 'response' | 'multipleChoice' | 'customMessage';
+type ChatControllerState = {
+    current: ChatMessage;
+    messages: ChatMessage[];
+};
+declare class ChatController {
+    #private;
+    id: string;
+    state: ChatControllerState;
+    constructor(id: string, welcomeMessage?: string);
+    components: {
+        MessageHistory: (() => react.JSX.Element) & {
+            displayName: string;
+        };
+        Textarea: (({ hideDeleteButton, isLoading: outIsLoading, onSubmit, preventAppendUserMessages, }: {
+            hideDeleteButton?: boolean | undefined;
+            isLoading?: boolean | undefined;
+            onSubmit: (chatMessage: ChatMessage) => Promise<void>;
+            preventAppendUserMessages?: boolean | undefined;
+        }) => react.JSX.Element) & {
+            displayName: string;
+        };
+    };
+    currentHistoryIndex: number;
+    audioRecorder: {
+        start: () => Promise<void>;
+        stop: () => Promise<void>;
+        record: number;
+        state: _apia_util.AudioRecorderState;
+    };
+    history: {
+        add: (message: ChatMessage) => void;
+        next: () => void;
+        previous: () => void;
+        updateState: (message?: ChatMessage) => void;
+        size: () => number;
+    };
+    messages: {
+        add: (message: ChatMessage, idx?: number) => void;
+        clear: () => void;
+    };
+    attachments: {
+        add: (...aiMessage: AIMessageAttachments[]) => void;
+        dropAll: () => undefined;
+        drop: (el: AIMessageAttachments) => void;
+        getComponents: () => react.JSX.Element[];
+        get: () => IAttachment[];
+        size: () => number;
+    };
+}
+
+type TMultipleChoiceMessageOption<OptionProps> = {
+    label: string;
+    url: string;
+    additionalProps?: OptionProps;
+};
+declare class MultipleChoiceMessage<OptionProps> extends ChatMessage {
+    constructor(question: string, options: TMultipleChoiceMessageOption<OptionProps>[], Renderer?: (props: {
+        item: TMultipleChoiceMessageOption<OptionProps>;
+    }) => ReactElement);
+}
+
+type TSearchResultState = {
+    title: string;
+    body: string;
+    link: string;
+};
+declare class SemanticSearchReference {
+    state: TSearchResultState;
+    constructor(props: TSearchResultState);
+    Component: () => react.JSX.Element;
+}
+
+/**
+ * @class SearchController:
+ *             - mobx Controller for the semantic search logic
+ *             - search for a term and get the results. This controller must be used
+ *               to maintain the state of the search string and of the results given a search string
+ */
+declare class SearchController {
+    static instance: SearchController;
+    state: {
+        queryString: string;
+        results: SemanticSearchReference[];
+        isLoading: boolean;
+        disabled: boolean;
+    };
+    protected constructor();
+    search(selectedId: string): Promise<void>;
+    protected setReferences(results: SemanticSearchReference[]): void;
+}
+
+type TReference = {
+    title: string;
+    body: string;
+    link: string;
+    isExternal: boolean;
+};
+interface ProcessingUnit {
+    visualizationType: TSearchMode;
+    content: string;
+    references: TReference[];
+    isExternal: boolean;
+}
+interface ListingProcessingUnit extends ProcessingUnit {
+    visualizationType: 'list';
+    title: string;
+    link: string;
+}
+interface ChatProcessingUnit extends ProcessingUnit {
+    visualizationType: 'chat';
+}
+declare const ViewRendererContext: react.Context<ISemanticSearchViewController>;
+type TSearchMode = 'list' | 'chat' | 'none';
+interface ISemanticSearchViewController {
+    state: {
+        filters: Record<string, FilterDTO>;
+        filtersOpen: boolean;
+        isLoading: boolean;
+        mode: TSearchMode;
+        searchString: string;
+    };
+    ResultsRenderer: FC;
+    clearHistory(): Promise<void>;
+    search(str?: string): void;
+    toggleFiltersOpen(): void;
+}
+type TResponseData = {
+    result: string;
+    success: string;
+    failed?: boolean;
+};
+interface ISearchResultsController<P extends ProcessingUnit> {
+    state: {
+        results: P[];
+    };
+    beforeSearch(props?: object): void;
+    afterSearch(props?: object): void;
+    clear(): void;
+    processResults(qryString: string, results: ProcessingUnit[], responseData?: TResponseData): void;
+    Component: FC;
+}
+
+declare class ResponseStream extends EventEmitter<{
+    part: string;
+}> {
+    private buffer;
+    private isRunning;
+    private locked;
+    private maxCompletionTime;
+    private minPartSize;
+    private partSize;
+    private timing;
+    private waiting;
+    private calculatePartSize;
+    emit<K extends 'part'>(_: K, data: {
+        part: string;
+    }[K]): void;
+    run(): void;
+}
+
+type RoutinesGenerationState = {
+    isLoading: boolean;
+    progress: number;
+};
+type TPollProgress = {
+    message: string;
+    progress: number;
+    debug: string;
+    streamPart?: string;
+};
+type TPollRoutineResult = {
+    status: string;
+    payload: unknown | TPollProgress;
+};
+type TGenerateFromImage$1 = {
+    base64: string;
+    description: string;
+};
+type TRoutineCompletion = Partial<{
+    images: TGenerateFromImage$1[];
+    parameters: Record<string, string>;
+    stream: ResponseStream;
+}> & {
+    routineName: string;
+};
+declare class RoutinesGeneration {
+    audioRecorder: AudioRecorder;
+    private routineId;
+    state: RoutinesGenerationState;
+    constructor();
+    private checkCanGenerate;
+    pollRoutine<T>(routineId: string, stream?: ResponseStream): Promise<T | null>;
+    private internalPollRoutine;
+    protected callAudioTranscription(audio: Blob): ReturnType<RoutinesGeneration['callRoutineStart']>;
+    protected callRoutinePoll(routineId: string): Promise<TPollRoutineResult>;
+    protected callRoutineStart(routineName: string, parameters: Record<string, string>, images: TGenerateFromImage$1[]): Promise<{
+        orchestrator: {
+            routineId: string;
+        };
+    } | null>;
+    private executeRoutine;
+    private resetLoading;
+    completion<T>(params: TRoutineCompletion): Promise<T | null>;
+    stop(): void;
+    transcribeAudio(audio: Blob): Promise<{
+        transcription: string;
+    } | null>;
+}
+
+declare class DashboardsRoutinesGeneration extends RoutinesGeneration {
+    protected dispatcher: TActionDispatcher;
+    constructor(dispatcher: TActionDispatcher);
+    private blobToBase64;
+    protected callAudioTranscription(audio: Blob): Promise<{
+        orchestrator: {
+            routineId: string;
+        };
+    } | null>;
+    protected callRoutinePoll(routineId: string): Promise<TPollRoutineResult>;
+    protected callRoutineStart(routineName: string, parameters: Record<string, string>, images: TGenerateFromImage$1[]): Promise<{
+        orchestrator: {
+            routineId: string;
+        };
+    } | null>;
+}
+
+type RetrievedImage = {
+    base64: string;
+    path: string;
+};
+declare function getImageFromDisk(inputProps?: Partial<{
+    accept: string;
+}>): Promise<RetrievedImage | null>;
+declare function getImagesFromDisk(inputProps?: Partial<{
+    accept: string;
+    multiple: string;
+}>): Promise<RetrievedImage[]>;
+
+type TGenerateFromImage = {
+    base64: string;
+    description: string;
+};
+declare function getImagesWithDescription({ multiple, }: {
+    multiple?: boolean;
+}): Promise<TGenerateFromImage[]>;
+
+export { AIMessageAttachments, AutoscrollContainer, ChatController, ChatController2, ChatMessage, type ChatProcessingUnit, DashboardsRoutinesGeneration, type ISearchResultsController, type ISemanticSearchViewController, type ListingProcessingUnit, MultipleChoiceMessage, type ProcessingUnit, ResponseStream, RoutinesGeneration, SearchController, SemanticSearchReference as SemanticSearchResult, type TGenerateFromImage$1 as TGenerateFromImage, type TMessageType, type TMultipleChoiceMessageOption, type TPollRoutineResult, type TReference, type TResponseData, type TRoutineCompletion, type TSearchMode, type ISemanticSearchViewController as ViewController, ViewRendererContext, getImageFromDisk, getImagesFromDisk, getImagesWithDescription };
+//# sourceMappingURL=index.d.ts.map

package/index.ts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}