@dataclouder/ngx-agent-cards 0.1.34 → 0.1.36

package/index.d.ts

@@ -1,5 +1,1082 @@
+import { ImgStorageData, CloudStorageData, IAssetable, StorageImageSettings } from '@dataclouder/ngx-cloud-storage';
+import * as _dataclouder_ngx_core from '@dataclouder/ngx-core';
+import { ChatUserSettings, EModelQuality, IAIModel, IManageable, EntityCommunicationService, FiltersConfig, IFilterQueryResponse, EntityBaseFormComponent, EntityBaseListComponent, ICustomFilter, PColumn, OnActionEvent } from '@dataclouder/ngx-core';
+import * as _angular_forms from '@angular/forms';
+import { FormGroup, FormControl, FormArray } from '@angular/forms';
+import { AudioEffectType, TTSRequest } from '@dataclouder/ngx-vertex';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Type, Provider, WritableSignal, Injector, Signal, OnInit, OnDestroy, TemplateRef } from '@angular/core';
+import { MicSettings } from '@dataclouder/ngx-mic';
+import * as _dataclouder_ngx_agent_cards from '@dataclouder/ngx-agent-cards';
+import { MenuItem } from 'primeng/api';
+import { UserService } from '@dataclouder/ngx-users';
+
+declare const defaultconvUserSettings: ChatUserSettings;
+declare class VoiceTTSOption {
+    provider: string;
+    name: string;
+    id: string;
+    gender: 'male' | 'female';
+    lang: string;
+    exampleUrl: string;
+}
+declare const VoiceTTSOptions: VoiceTTSOption[];
+declare enum AudioSpeed {
+    VerySlow = "verySlow",
+    Slow = "slow",
+    Regular = "regular",
+    Fast = "fast",
+    VeryFast = "veryFast"
+}
+declare enum TextEngines {
+    SimpleText = "simpleText",
+    MarkdownMultiMessages = "markdownMultiMessages",
+    MarkdownSSML = "markdownSSML"
+}
+declare const TextEngineOptions: {
+    value: TextEngines;
+    label: string;
+}[];
+declare enum ConversationType$1 {
+    Default = "default",
+    General = "general",
+    Reflection = "reflection",
+    Challenge = "challenge",
+    RolePlay = "rolePlay",
+    RolePlayNoNarrator = "rolePlayNoNarrator",
+    RolePlayInnerThoughts = "rolePlayInnerThoughts",
+    LearningExample = "learningExample",
+    Scenario = "scenario",
+    LanguagePractice = "languagePractice"
+}
+declare const ConversationTypeOptions: {
+    value: ConversationType$1;
+    label: string;
+}[];
+
+type ModelFormGroup = FormGroup<{
+    id: FormControl<string>;
+    modelName: FormControl<string>;
+    provider: FormControl<string>;
+    quality: FormControl<EModelQuality>;
+}>;
+declare enum EDoActionType {
+    ChangePrompt = "changePrompt",// Este es context Prompt
+    ChangeDynamicFlowTask = "changeDynamicFlowTask",// Change AI Task since
+    ChangeModel = "changeModel",// Just a thought Not implemented yet
+    Summarize = "summarize"
+}
+declare const DoActionTypeOptions: {
+    label: string;
+    value: EDoActionType;
+}[];
+declare enum EDynamicFlowTaskType {
+    Goal = "goal",
+    Tools = "tools",
+    Challenges = "challenges",
+    OnUserMessage = "onUserMessage",
+    OnAssistantMessage = "onAssistantMessage",
+    OnGoalCompleted = "onGoalCompleted"
+}
+declare const DynamicFlowTaskTypeOptions: {
+    label: string;
+    value: EDynamicFlowTaskType;
+}[];
+declare enum SystemPromptType {
+    SystemPrompt = "systemPrompt",
+    Language = "language",
+    ConversationType = "conversationType",
+    PictureDescription = "pictureDescription",
+    UserInformation = "userInformation",
+    CharacterDescription = "characterDescription",
+    ScenarioDescription = "scenarioDescription",
+    MessageExamples = "messageExamples",
+    JailBreak = "jailBreak"
+}
+interface ChangePromptAction {
+    actionType: EDoActionType;
+    systemPromptType: SystemPromptType;
+    prompt: string;
+}
+type SimpleAgentTaskFormGroup = FormGroup<{
+    systemPrompt: FormControl<string>;
+    task: FormControl<string>;
+    expectedResponseType: FormControl<string>;
+    modelQuality: FormControl<EModelQuality>;
+    model: ModelFormGroup;
+    enabled: FormControl<boolean>;
+}>;
+type DynamicCriteriaFormGroup = FormGroup<{
+    name: FormControl<string>;
+    description: FormControl<string>;
+    enabled: FormControl<boolean>;
+    emoji: FormControl<string>;
+}>;
+type DoActionFormGroup = FormGroup<{
+    actionType: FormControl<string>;
+    systemPromptType: FormControl<string>;
+    dynamicFlowTaskType: FormControl<string>;
+    prompt: FormControl<string>;
+    enabled: FormControl<boolean>;
+}>;
+type DynamicConditionFormGroup = FormGroup<{
+    what: FormControl<string>;
+    when: FormControl<string>;
+    value: FormControl<string>;
+    then: FormControl<any[]>;
+    do: FormArray<DoActionFormGroup>;
+}>;
+type TriggerTasksFormGroup = FormGroup<{
+    [ConversationEvents.OnUserMessage]: SimpleAgentTaskFormGroup;
+    [ConversationEvents.OnAssistantMessage]: SimpleAgentTaskFormGroup;
+    [ConversationEvents.OnGoalCompleted]: SimpleAgentTaskFormGroup;
+}>;
+type ConversationFlowFormGroup = FormGroup<{
+    goal: SimpleAgentTaskFormGroup;
+    triggerTasks: TriggerTasksFormGroup;
+    challenges: FormArray<DynamicCriteriaFormGroup>;
+    tools: FormArray<DynamicCriteriaFormGroup>;
+    dynamicConditions: FormArray<DynamicConditionFormGroup>;
+}>;
+type ConversationSettingsFormGroup = FormGroup<{
+    textEngine: FormControl<TextEngines>;
+    conversationType: FormControl<ConversationType$1>;
+    autoStart: FormControl<boolean>;
+    tts: FormGroup<{
+        voice: FormControl<string>;
+        secondaryVoice: FormControl<string>;
+        speed: FormControl<string>;
+        speedRate: FormControl<number>;
+    }>;
+}>;
+
+interface Appearance {
+    generalDescription: string;
+    physicalDescription: string;
+    outfit: string;
+    objects: string;
+    quirks: string;
+}
+interface CharacterCardData {
+    name: string;
+    description: string;
+    scenario?: string;
+    first_mes?: string;
+    creator_notes?: string;
+    mes_example?: string;
+    alternate_greetings?: string[];
+    tags?: string[];
+    system_prompt?: string;
+    post_history_instructions?: string;
+    character_version?: string;
+    extensions?: Record<string, any>;
+    picture_description?: string;
+    appearance?: Appearance;
+}
+declare const characterCardStringDataDefinition = "\ninterface CharacterCardData {\n  name: string;                      // Character's name\n  description: string;               // General character description\n  scenario: string;                  // The setting or context where the character exists\n  first_mes: string;                 // First message the character will say\n  mes_example: string;               // Example of character's typical message/dialogue\n  alternate_greetings: string[];     // Array of alternative greeting messages\n  tags: string[];                    // Array of descriptive tags\n  appearance: string;                // Physical description including height, build, hair color/style, eye color, skin tone, distinctive marks, clothing style, current outfit\n}";
+interface ICharacterCardDC {
+    spec?: 'chara_card_v2';
+    spec_version?: '2_v_dc';
+    data: CharacterCardData;
+}
+interface ITTS {
+    voice: string;
+    secondaryVoice?: string;
+    speed?: AudioSpeed;
+    speedRate?: number;
+}
+interface IAgentMetadata {
+    isPublished: boolean;
+    isPublic: any;
+    authorId: string;
+    authorEmail: string;
+    createdAt: Date;
+    updatedAt: Date;
+    takenCount: number;
+    level: number;
+}
+interface VoiceTTS {
+    voice: string;
+    speedRate?: number;
+    lang?: string;
+    effect?: string;
+    model?: string;
+    provider?: string;
+    options?: Record<string, any>;
+}
+interface IConversationSettings {
+    modelQuality?: EModelQuality;
+    textEngine?: TextEngines;
+    conversationType?: ConversationType$1;
+    tts?: ITTS;
+    autoStart?: boolean;
+    messages?: ChatMessage[];
+    last_prompt?: string;
+    repeatRecording?: boolean;
+    model?: IAIModel;
+    mainVoice?: VoiceTTS;
+    secondaryVoice?: VoiceTTS;
+}
+type IConversationSettingsDTO = Partial<IConversationSettings> & {
+    returnJson?: boolean;
+};
+interface IAgentResponseDTO {
+    role: ChatRole;
+    content: string | object;
+    metadata: {
+        tokens: {
+            input: number;
+            output: number;
+            total: number;
+        };
+        model: string;
+        processTime: number;
+        recovered: boolean;
+    };
+}
+interface IAgentAssets {
+    image?: ImgStorageData;
+    motion?: CloudStorageData;
+    bannerImg?: ImgStorageData;
+    stickers?: Array<ImgStorageData>;
+}
+declare enum ConditionType {
+    Goal = "goal",
+    Challenges = "challenges",
+    NumMessages = "numMessages",
+    Time = "time"
+}
+declare const EntityWhatOptions: {
+    label: string;
+    value: ConditionType;
+}[];
+declare enum ConditionOperator {
+    LowerThan = "<",
+    LowerThanOrEqual = "<=",
+    Equal = "=",
+    GreaterThanOrEqual = ">=",
+    GreaterThan = ">"
+}
+declare const EntityWhenOptions: {
+    label: string;
+    value: ConditionOperator;
+}[];
+declare enum EntityThen {
+    ChangePrompt = "changePrompt"
+}
+type DoAction = {
+    actionType: EDoActionType;
+    systemPromptType?: SystemPromptType;
+    dynamicFlowTaskType?: EDynamicFlowTaskType;
+    prompt?: string;
+    enabled?: boolean;
+};
+interface IDynamicCondition {
+    what: ConditionType;
+    when: ConditionOperator;
+    value: string | number;
+    do?: DoAction[];
+}
+interface IDynamicCriteria {
+    enabled: boolean;
+    name: string;
+    description: string;
+    emoji?: string;
+}
+interface IConversationFlow {
+    goal: IDynamicFlowTask;
+    tools?: IDynamicCriteria[];
+    triggerTasks: Partial<Record<ConversationEvents, IDynamicFlowTask>>;
+    challenges?: IDynamicCriteria[];
+    dynamicConditions: IDynamicCondition[];
+}
+declare enum EAgentType {
+    None,
+    Social = "social",
+    Character = "character"
+}
+interface IAgentCard {
+    version?: string;
+    _id?: string;
+    id?: string;
+    title?: string;
+    description?: string;
+    agentType?: EAgentType;
+    lang?: string;
+    assets?: IAssetable;
+    characterCard?: ICharacterCardDC;
+    conversationSettings?: IConversationSettings;
+    metaApp?: IAgentMetadata;
+    accounts?: Array<IAccounts>;
+    conversationFlow?: IConversationFlow;
+    manageable?: IManageable;
+}
+interface IAgentCardMeta extends IAgentCard {
+    taken: any;
+}
+declare const EvalResultStringDefinition = "\ninterface SimpleEvalResult {\n  score: number;                       // Score of the user's response 0 to 3\n  feedback: string;                    // Feedback of the user's understanding of the conversation\n}";
+interface SimpleEvalResult {
+    score: number;
+    feedback: string;
+}
+interface ISimpleAgent {
+    systemPrompt: string;
+    model: IAIModel;
+}
+interface SimpleAgentTask {
+    task: string;
+    modelQuality?: EModelQuality;
+    expectedResponseType?: string;
+    systemPrompt?: string;
+    model?: IAIModel;
+    enabled?: boolean;
+}
+type IDynamicFlowTask = Pick<SimpleAgentTask, 'task' | 'model' | 'enabled'>;
+declare enum EAccountsPlatform {
+    Tiktok = "tiktok",
+    Instagram = "instagram",
+    Youtube = "youtube"
+}
+interface IAccounts {
+    platform: EAccountsPlatform;
+    user: string;
+    email: string;
+    authMethod: string;
+    pass: string;
+}
+type TranscriptionsWhisper = {
+    text: string;
+    task: string;
+    language: string;
+    words?: any[];
+    duration: number;
+    segments?: any[];
+};
+declare class WordTimestamps {
+    word: string;
+    start: number;
+    end: number;
+    highlighted: boolean;
+}
+declare class MessageContent {
+    audioUrl?: string;
+    audioPromise?: any;
+    isLoading?: boolean;
+    transcription?: TranscriptionsWhisper;
+    transcriptionTimestamps?: WordTimestamps[];
+    text?: string;
+    content?: string;
+    voice?: string;
+    shouldPlayAudio?: boolean;
+    messageId?: string;
+    tag?: string;
+    ssml?: string;
+    audioEffect?: AudioEffectType;
+}
+declare enum ChatRole {
+    System = "system",
+    User = "user",
+    Assistant = "assistant",
+    AssistantHelper = "assistantHelper"
+}
+declare class ChatMessage extends MessageContent {
+    role: ChatRole;
+    translation?: string;
+    audioHtml?: HTMLAudioElement;
+    promisePlay?: any;
+    stats?: any;
+    multiMessages?: MessageContent[];
+    evaluation?: Record<string, any>;
+    tags?: string[];
+    imgUrl?: string;
+    generatedImg?: string;
+}
+declare class ConversationMessagesDTO {
+    messages?: ChatMessage[];
+    modelName?: string;
+    provider?: string;
+    type?: ConversationType$1;
+}
+declare class ConversationDTO {
+    id?: string;
+    entityId?: string;
+    type?: ConversationType$1;
+    createdAt?: Date;
+    messages: Array<ChatMessage>;
+    transcription?: boolean;
+    modelName?: string;
+    provider?: string;
+    returnJson?: boolean;
+}
+interface ModelName {
+    id: string;
+    name: string;
+}
+type AudioGenerated = {
+    blobUrl: string;
+    transcription: any;
+};
+interface BackgroundTask {
+    task: SimpleAgentTask;
+    event: ConversationEvents;
+}
+declare enum ConversationEvents {
+    OnUserMessage = "onUserMessage",
+    OnAssistantMessage = "onAssistantMessage",
+    OnGoalCompleted = "onGoalCompleted",
+    OnInitConversation = "onInitConversation",
+    OnEndConversation = "onEndConversation"
+}
+declare enum ChatEventType {
+    WordClicked = "wordClicked"
+}
+interface ChatEvent<T = any> {
+    type: ChatEventType;
+    payload: T;
+}
+declare enum ContextType {
+    CurrentMessageContent = "MessageContent",
+    LastAssistantMessage = "LastAssistantMessage",
+    LastUserMessage = "LastUserMessage",
+    LastMessage = "LastMessage",// Last User + Last Assistant
+    Last2Messages = "Last2Messages",
+    Last3Messages = "Last3Messages",
+    Last4Messages = "Last4Messages",
+    LastUserAndPreviousAssistant = "LastUserAndPreviousAssistant",
+    AllConversation = "AllConversation"
+}
+
+declare class DefaultAgentCardsService extends EntityCommunicationService<IAgentCard> {
+    private conversationCostService;
+    constructor();
+    partialUpdateAgentCard(agentCard: IAgentCard): Promise<IAgentCard>;
+    generateMainImage(idCard: string): Promise<any>;
+    completeAgentCard(idCard: string): Promise<any>;
+    callChatCompletion(conversation: IConversationSettingsDTO, tag?: string): Promise<IAgentResponseDTO>;
+    filterConversationCards(filters: FiltersConfig): Promise<IFilterQueryResponse<IAgentCard>>;
+    getAllConversationCards(): Promise<IAgentCard[]>;
+    findFilteredAgentCards(paginator: FiltersConfig): Promise<IFilterQueryResponse<IAgentCard>>;
+    findAgentCardByTitle(title: string): Promise<IAgentCard>;
+    remove(id: string): Promise<void>;
+    getConversationUserChatSettings(): Promise<ChatUserSettings>;
+    getListModels(provider: string): Promise<ModelName[]>;
+    translateConversation(currentLang: string, targetLang: string, id: string): Promise<ChatUserSettings>;
+    getAudioTranscriptions(audio: Blob, options: unknown): Promise<TranscriptionsWhisper>;
+    callInstruction(prompt: string, model: IAIModel): Promise<IAgentResponseDTO>;
+    saveConversationUserChatSettings(settings: ChatUserSettings): Promise<ChatUserSettings>;
+    generateImageForCard(idCard: string): Promise<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DefaultAgentCardsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DefaultAgentCardsService>;
+}
+
+declare const CONVERSATION_AI_TOKEN: InjectionToken<DefaultAgentCardsService>;
+declare function provideAgentCardService(serviceImplementation: Type<DefaultAgentCardsService>): Provider[];
+
+declare function extractJsonFromResponse(content: string): any;
+
+interface UserDataExchange {
+    imgUrl: string;
+    name: string;
+    gender: string;
+    age: number;
+    baseLang?: string;
+    targetLang?: string;
+}
+declare const USER_DATA_EXCHANGE: InjectionToken<UserDataExchangeAbstractService>;
+declare function provideUserDataExchange(serviceImplementation: Type<UserDataExchangeAbstractService>): Provider[];
+declare abstract class UserDataExchangeAbstractService {
+    abstract getUserDataExchange(): UserDataExchange;
+    abstract getUserDataDescriptions(): {
+        key: string;
+        value: any;
+        description: string;
+    }[];
+    abstract getParseDict(): {
+        [key: string]: string;
+    };
+    abstract getUserChatSettings(): ChatUserSettings;
+    abstract getUserDataInformation(): string;
+}
+
+declare const getMoodStateLabelsAsString: () => string;
+declare const MOOD_STATE_PROMPT: string;
+
+declare function markdownToHtml(markdown: string): any;
+declare function convertToHTML(text: string): any;
+declare function removeEmojisAndSpecialCharacters(text: string): string;
+declare function removeEmojis(text: string): string;
+declare function removeSpecialCharacters(inputText: string): string;
+
+declare class AudioService {
+    private currentAudio;
+    playFinishRecordingAudio(): void;
+    playFinishRecordingAudio2(): void;
+    playReflectionAudio(): void;
+    playAudio(audioUrl: string): HTMLAudioElement;
+    stopAudio(): void;
+    private successAudio;
+    private mistakeAudio;
+    private writtngAudio;
+    private coinAudio;
+    private noValid;
+    constructor();
+    playSuccess(): void;
+    playNoValid(): void;
+    playMistake(): Promise<void>;
+    playWriting(): void;
+    playCoins(n: number): void;
+    play2Coins(): Promise<void>;
+    play3Coins(): Promise<void>;
+    playWithSrc(source: any): Promise<void>;
+    getSpeedRate(speed: any): number;
+    playAudioWithStoragePath(path: string): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AudioService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AudioService>;
+}
+
+declare class ConversationPromptBuilderService {
+    private userDataExchange;
+    buildConversationSettings(agentCard: IAgentCard, parseDict?: {
+        [key: string]: string;
+    }): IConversationSettings;
+    buildConversationMessages(agentCard: IAgentCard, parseDict?: {
+        [key: string]: string;
+    }): ChatMessage[];
+    private getDefaultParseDict;
+    getDefaultCardParseDict(card: IAgentCard): {
+        [key: string]: string;
+    };
+    convertConversationToHtml(messages: ChatMessage[], jailBrake?: string): string;
+    private parseConversation;
+    applyReplacements(text: string, replacements: {
+        [key: string]: string;
+    }): string;
+    private buildInitialConversation;
+    private selectOneRandomGreeting;
+    private sampleSize;
+    getJailBrakePrompt(conversation: IAgentCard, parseDict?: {
+        [key: string]: string;
+    }): string;
+    getConversationSettings(agent: IAgentCard, chatMessages: ChatMessage[], jailBrakePrompt: string): IConversationSettings;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConversationPromptBuilderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ConversationPromptBuilderService>;
+}
+
+interface WordData {
+    word: string;
+    index: number;
+    messageId: string;
+}
+declare class PopupService {
+    private renderer;
+    private document;
+    private rendererFactory;
+    private appRef;
+    private injector;
+    private environmentInjector;
+    private currentPopupContainer;
+    private currentComponentRef;
+    readonly selectedWord: WritableSignal<WordData>;
+    private clickListenerUnlisten;
+    constructor();
+    /**
+     * Shows a popup containing a dynamically created component.
+     * @param top Position from the top of the viewport.
+     * @param left Position from the left of the viewport.
+     * @param componentType The type of component to render inside the popup.
+     * @param injector The injector to use for the dynamic component.
+     * @param wordData The WordData to pass to the component's input signal.
+     */
+    showPopup<T extends {
+        wordData: WritableSignal<WordData | null>;
+    }>(// Constrain T
+    top: number, left: number, componentType: Type<T>, injector: Injector, wordData: WordData): void;
+    /**
+     * Hides the currently displayed popup and destroys the dynamic component.
+     */
+    hidePopup(): void;
+    private addOutsideClickListener;
+    private removeOutsideClickListener;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopupService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PopupService>;
+}
+
+declare class DynamicFlowService {
+    private messagesStateService;
+    conversationFlowState: _angular_core.WritableSignal<IConversationFlow>;
+    setConversationFlow(conversationFlow: IConversationFlow): void;
+    changePrompt(): void;
+    applyConditionChange(condition: IDynamicCondition): void;
+    changeDynamicFlowTask(action: DoAction): void;
+    doActionPrompt(action: DoAction): void;
+    removeSystemPrompts(): void;
+    checkDynamicConditions(previousScore: number, currentScore: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicFlowService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DynamicFlowService>;
+}
+
+declare class GlobalToolsService {
+    useTool(tool: string, ...args: any[]): Promise<any>;
+    getAvailibleTools(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GlobalToolsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GlobalToolsService>;
+}
+
+declare class ContextEngineService {
+    private messagesStateSvc;
+    private userService;
+    getUserData(): string;
+    getEntityContext<T extends {
+        id: string;
+        name: string;
+        description?: string;
+    }>(entity: T): any;
+    getConversationContext(contextType: ContextType): string;
+    getContextMessages(contextType: ContextType): ChatMessage[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContextEngineService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ContextEngineService>;
+}
+
+declare class ChatMonitorService {
+    constructor();
+    private readonly messageAudioWillPlay;
+    readonly messageAudioWillPlay$: _angular_core.Signal<MessageContent>;
+    logMessageAudioWillPlay(message: MessageContent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatMonitorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChatMonitorService>;
+}
+
+declare class MessagesStateService {
+    private messagesSignal;
+    getMessagesSignal(): Signal<ChatMessage[]>;
+    addMessage(message: ChatMessage): string;
+    updateMessage(messageId: string, updatedMessage: Partial<ChatMessage>, insertIfNotFound?: boolean): boolean;
+    clearMessages(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessagesStateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MessagesStateService>;
+}
+
+declare class AIGenerationService {
+    private vertexService;
+    private messagesStateService;
+    private conversationService;
+    generateImage(chatMessage: ChatMessage, chatText: string): Promise<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AIGenerationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AIGenerationService>;
+}
+
+type EvaluationLevel = 1 | 2 | 3 | 4 | 5;
+type CommunicationLevel = 'Beginner' | 'Intermediate' | 'Advanced' | 'Native-like';
+type DominantRegister = 'formal' | 'informal' | 'mixed';
+type ConversationType = 'casual' | 'academic' | 'professional' | 'social';
+interface OverallScore {
+    rating: number;
+    level: EvaluationLevel;
+}
+interface Assessment {
+    score: number;
+    level: EvaluationLevel | CommunicationLevel;
+    feedback: string;
+    suggestions: string[];
+}
+interface Assessments {
+    grammar: Assessment;
+    vocabulary: Assessment;
+    communication_effectiveness: Assessment;
+    pragmatic_competence: Assessment;
+}
+interface ConversationAnalysis {
+    dominant_register: DominantRegister;
+    conversation_type: ConversationType;
+    key_observations: string[];
+    notable_patterns: string[];
+}
+interface ActionableFeedback {
+    immediate_focus_areas: string[];
+    practice_recommendations: string[];
+    next_steps: string[];
+}
+interface PerformanceEvaluation {
+    overall_score: OverallScore;
+    assessments: Assessments;
+    conversation_analysis: ConversationAnalysis;
+    actionable_feedback: ActionableFeedback;
+}
+
+interface IEvaluationResponse {
+    text: string;
+    score: number;
+}
+declare class EvaluationService {
+    private defaultAgentCardService;
+    private toastService;
+    private dynamicFlowService;
+    private contextEngineService;
+    private dialogService;
+    private loadingBarService;
+    scoreSignal: _angular_core.WritableSignal<number>;
+    private evaluationResultSignal;
+    evaluateGoal(goalTask: IDynamicFlowTask): Promise<any>;
+    evaluateConversation(task: SimpleAgentTask, contextType?: ContextType): Promise<IEvaluationResponse>;
+    /**
+     * Diference with evaluateConversation is task is already processed here.
+     * Evaluates a conversation context based on a specific task and attaches the result to a designated message.
+     * @param agentTask The task definition for the evaluation.
+     * @param messageToUpdate The specific ChatMessage object (user or assistant) to attach the evaluation results to.
+     * @param contextType Determines which part of the conversation history to send as context (default: AllConversation).
+     * @returns The JSON result of the evaluation.
+     */
+    evaluateWithTask(agentTask: IDynamicFlowTask): Promise<any>;
+    updateScore(additionalScore: number): void;
+    setScore(newScore: number): void;
+    resetScore(): void;
+    analylizePerformance(): Promise<any>;
+    openFeedbackEvaluation(data?: PerformanceEvaluation): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EvaluationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EvaluationService>;
+}
+
+declare class DCChatComponent implements OnInit, OnDestroy {
+    private conversationInfoService;
+    private conversationService;
+    evaluationService: EvaluationService;
+    private userDataExchange;
+    messageStateService: MessagesStateService;
+    private dialogService;
+    private chatMonitorService;
+    private chatFooterComponent;
+    chatUserSettings: ChatUserSettings;
+    conversationSettings: IConversationSettings;
+    conversationFlow: IConversationFlow | null;
+    agentCard: IAgentCard;
+    readonly parseDict: _angular_core.InputSignal<{
+        [key: string]: string;
+    }>;
+    readonly chatEvent: _angular_core.OutputEmitterRef<ChatEvent<any>>;
+    readonly goalCompleted: _angular_core.OutputEmitterRef<void>;
+    messages: _angular_core.WritableSignal<ChatMessage[]>;
+    micSettings: MicSettings;
+    isAdmin: boolean;
+    constructor();
+    ngOnInit(): Promise<void>;
+    ngOnDestroy(): void;
+    /**
+     * Open chat settings dialog
+     */
+    changeUserChatSettings(): void;
+    /**
+     * Show debug info
+     */
+    showInfo(): void;
+    /**
+     * Restart conversation
+     */
+    restartConversation(conversation?: IAgentCard | null): Promise<void>;
+    complete(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DCChatComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DCChatComponent, "dc-chat", never, { "chatUserSettings": { "alias": "chatUserSettings"; "required": false; }; "conversationSettings": { "alias": "conversationSettings"; "required": false; }; "conversationFlow": { "alias": "conversationFlow"; "required": false; }; "agentCard": { "alias": "agentCard"; "required": false; }; "parseDict": { "alias": "parseDict"; "required": false; "isSignal": true; }; }, { "chatEvent": "chatEvent"; "goalCompleted": "goalCompleted"; }, never, never, true, never>;
+}
+
+declare class DCAgentCardFormComponent extends EntityBaseFormComponent<IAgentCard> {
+    private fb;
+    protected entityCommunicationService: _dataclouder_ngx_agent_cards.DefaultAgentCardsService;
+    private dialogService;
+    private promptBuilder;
+    private formGroupService;
+    conversationOptions: {
+        value: ConversationType$1;
+        label: string;
+    }[];
+    voiceTTSOptions: _dataclouder_ngx_agent_cards.VoiceTTSOption[];
+    textEngineOptions: {
+        value: TextEngines;
+        label: string;
+    }[];
+    languageOptions: {
+        value: string;
+        label: string;
+    }[];
+    agentTypeOptions: (string | EAgentType.None)[];
+    readonly storageSettings: _angular_core.InputSignal<StorageImageSettings>;
+    readonly onSave: _angular_core.OutputEmitterRef<any>;
+    readonly onGoDetails: _angular_core.OutputEmitterRef<string>;
+    readonly onTranslate: _angular_core.OutputEmitterRef<any>;
+    private getSettings;
+    form: FormGroup<{
+        version: _angular_forms.FormControl<string>;
+        id: _angular_forms.FormControl<string>;
+        title: _angular_forms.FormControl<string>;
+        description: _angular_forms.FormControl<string>;
+        lang: _angular_forms.FormControl<string>;
+        agentType: _angular_forms.FormControl<EAgentType>;
+        characterCard: FormGroup<any>;
+        conversationSettings: FormGroup<{
+            textEngine: _angular_forms.FormControl<TextEngines>;
+            conversationType: _angular_forms.FormControl<ConversationType$1>;
+            autoStart: _angular_forms.FormControl<boolean>;
+            mainVoice: FormGroup<any>;
+            secondaryVoice: FormGroup<any>;
+            model: FormGroup<{
+                quality: _angular_forms.FormControl<_dataclouder_ngx_core.EModelQuality>;
+                modelName: _angular_forms.FormControl<string>;
+                provider: _angular_forms.FormControl<string>;
+                id: _angular_forms.FormControl<string>;
+            }>;
+        }>;
+        metaApp: FormGroup<any>;
+        accounts: FormArray<_angular_forms.FormControl<unknown>>;
+        conversationFlow: FormGroup<{
+            goal: _dataclouder_ngx_agent_cards.SimpleAgentTaskFormGroup;
+            triggerTasks: _dataclouder_ngx_agent_cards.TriggerTasksFormGroup;
+            challenges: FormArray<_dataclouder_ngx_agent_cards.DynamicCriteriaFormGroup>;
+            tools: FormArray<_dataclouder_ngx_agent_cards.DynamicCriteriaFormGroup>;
+            dynamicConditions: FormArray<_dataclouder_ngx_agent_cards.DynamicConditionFormGroup>;
+        }>;
+        manageable: FormGroup<any>;
+    }>;
+    protected patchForm(agentCard: IAgentCard): void;
+    save(): Promise<IAgentCard | undefined>;
+    onImageSelected(file: File): Promise<void>;
+    checkPrompt(): void;
+    goToDetails(): void;
+    translate(): void;
+    downloadConversation(): void;
+    importConversation(): void;
+    isGenerating: _angular_core.WritableSignal<boolean>;
+    generateCharacter(): Promise<void>;
+    generateMissingData(): Promise<void>;
+    onUpdateAsset(event: {
+        assets: Partial<IAssetable>;
+    }): void;
+    onAssetsChange(event: IAssetable): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DCAgentCardFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DCAgentCardFormComponent, "dc-agent-form", never, { "storageSettings": { "alias": "storageSettings"; "required": false; "isSignal": true; }; }, { "onSave": "onSave"; "onGoDetails": "onGoDetails"; "onTranslate": "onTranslate"; }, never, never, true, never>;
+}
+
+declare class AgentCardListComponent extends EntityBaseListComponent<IAgentCard> implements OnInit {
+    extraFilters: ICustomFilter[];
+    readonly showOptions: _angular_core.InputSignal<boolean>;
+    readonly gridLayout: _angular_core.InputSignal<boolean>;
+    readonly customGetButtons: _angular_core.InputSignal<(card: IAgentCard) => MenuItem[]>;
+    protected entityCommunicationService: DefaultAgentCardsService;
+    private toastService;
+    columns: PColumn[];
+    customFilters: ICustomFilter[];
+    constructor();
+    getCustomButtons(item: IAgentCard): MenuItem[];
+    ngOnInit(): Promise<void>;
+    handleTableAction(actionEvent: OnActionEvent): void;
+    getCardMeta(card: IAgentCard): IAgentCardMeta;
+    handleAction(actionEvent: OnActionEvent): void;
+    applyFilterBarEvent(filterEvent: OnActionEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgentCardListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgentCardListComponent, "dc-agent-card-lists", never, { "extraFilters": { "alias": "extraFilters"; "required": false; }; "showOptions": { "alias": "showOptions"; "required": false; "isSignal": true; }; "gridLayout": { "alias": "gridLayout"; "required": false; "isSignal": true; }; "customGetButtons": { "alias": "customGetButtons"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DcAgentCardDetailsComponent implements OnInit {
+    private agentCardService;
+    private route;
+    private toastService;
+    agentCardId: string;
+    readonly onStartConversation: _angular_core.OutputEmitterRef<IAgentCard>;
+    agentCard: _angular_core.WritableSignal<IAgentCard>;
+    showInfoLayer: _angular_core.WritableSignal<boolean>;
+    mediaType: _angular_core.Signal<"image" | "video">;
+    mediaUrl: _angular_core.Signal<string>;
+    ngOnInit(): Promise<void>;
+    startConversation(): void;
+    toggleInfoLayer(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DcAgentCardDetailsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DcAgentCardDetailsComponent, "dc-agent-card-details", never, { "agentCardId": { "alias": "agentCardId"; "required": false; }; }, { "onStartConversation": "onStartConversation"; }, never, never, true, never>;
+}
+
+declare enum EventCard {
+    Edit = "edit",
+    Delete = "delete",
+    Select = "select",
+    Clone = "clone"
+}
+declare class AgentCardUI implements OnInit {
+    eventType: typeof EventCard;
+    userService: UserService;
+    speedDialModel: MenuItem[];
+    ngOnInit(): void;
+    readonly card: _angular_core.InputSignal<IAgentCard>;
+    readonly showOptions: _angular_core.InputSignal<boolean>;
+    readonly onAction: _angular_core.OutputEmitterRef<OnActionEvent>;
+    eventCard(eventType: EventCard): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgentCardUI, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgentCardUI, "dc-agent-card-ui", never, { "card": { "alias": "card"; "required": false; "isSignal": true; }; "showOptions": { "alias": "showOptions"; "required": false; "isSignal": true; }; }, { "onAction": "onAction"; }, never, never, true, never>;
+}
+
+interface ModelData {
+    id: string;
+    name: string;
+    description: string;
+}
+declare function createAIModelFormGroup(task?: SimpleAgentTask): _angular_forms.FormGroup<{
+    quality: _angular_forms.FormControl<EModelQuality>;
+    modelName: _angular_forms.FormControl<string>;
+    provider: _angular_forms.FormControl<string>;
+    id: _angular_forms.FormControl<string>;
+}>;
 /**
- * Generated bundle index. Do not edit.
+ * A component that provides AI model provider selection functionality.
+ * This component allows users to select an AI provider and displays available models
+ * for the selected provider, you need to handle values logic in the parent component.
+ * you have to pass the parent form group to the component, with controls: provider and modelName.
+ *
+ * @example
+ * ```html
+ * <dc-model-selector
+ *   [parentForm]="yourFormGroup">
+ * </dc-model-selector>
+ * ```
  */
-/// <amd-module name="@dataclouder/ngx-agent-cards" />
-export * from './public-api';
+declare class ModelSelectorComponent implements OnInit {
+    private conversationCardAIService;
+    private cdr;
+    /** Parent form group that contains provider and model selection controls */
+    modelForm: _angular_forms.FormGroup<{
+        quality: _angular_forms.FormControl<EModelQuality>;
+        modelName: _angular_forms.FormControl<string>;
+        provider: _angular_forms.FormControl<string>;
+        id: _angular_forms.FormControl<string>;
+    }>;
+    shortForm?: boolean;
+    /** Flag indicating whether the models are currently being loaded */
+    isLoadingModels: boolean;
+    /** Array of available models for the selected provider */
+    modelnames: ModelData[];
+    providersOptions: {
+        label: string;
+        value: string;
+    }[];
+    /**
+     * Initializes the component by setting up subscriptions to provider changes
+     * and loading initial models if a provider is already selected.
+     */
+    ngOnInit(): void;
+    modelQualityOptions: {
+        label: string;
+        value: EModelQuality;
+    }[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModelSelectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModelSelectorComponent, "dc-model-selector", never, { "modelForm": { "alias": "modelForm"; "required": false; }; "shortForm": { "alias": "shortForm"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IWordMetadata {
+    word: string;
+    index: number;
+    isHighlighted?: boolean;
+    tag?: string;
+}
+type AudioState = 'idle' | 'playing' | 'paused' | 'loading' | 'playable';
+declare class MessageContentDisplayer implements OnDestroy {
+    message: _angular_core.InputSignal<MessageContent>;
+    readonly playAudio: _angular_core.OutputEmitterRef<MessageContent>;
+    readonly audioCompleted: _angular_core.OutputEmitterRef<MessageContent>;
+    readonly wordClicked: _angular_core.OutputEmitterRef<{
+        word: string;
+        index: number;
+        messageId: string;
+    }>;
+    wordWithMeta: _angular_core.WritableSignal<IWordMetadata[]>;
+    audioState: _angular_core.WritableSignal<AudioState>;
+    alreadyPlayed: boolean;
+    wordsWithMetaState: IWordMetadata[];
+    iconState: _angular_core.Signal<"paused" | "idle" | "playing" | "loading" | "playable">;
+    shouldPlayAudio: _angular_core.Signal<boolean>;
+    messageText: _angular_core.Signal<string>;
+    classTag: _angular_core.Signal<string>;
+    hasTranscription: _angular_core.Signal<boolean>;
+    private audioElement;
+    private destroy$;
+    private destroyRef;
+    constructor();
+    trackByIndex(index: number, item: any): number;
+    ngOnDestroy(): void;
+    private initializeBasedOnMessage;
+    private initializeAudio;
+    private subcribeToAudioSync;
+    private subscribeToEndAudio;
+    private cleanupAudio;
+    onPlayMessage(): void;
+    private initializePlainTextWords;
+    onWordClick(wordData: {
+        word: string;
+        index: number;
+    } | IWordMetadata): void;
+    private startAudioPlayback;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageContentDisplayer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageContentDisplayer, "message-content-displayer", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; }, { "playAudio": "playAudio"; "audioCompleted": "audioCompleted"; "wordClicked": "wordClicked"; }, never, never, true, never>;
+}
+
+declare function matchTranscription(originalText: string, transcription: any[]): any[];
+declare function extractAudioAndTranscription(message: MessageContent, audio: AudioGenerated): MessageContent;
+declare function buildObjectTTSRequest(message: MessageContent, settings?: ChatUserSettings): TTSRequest;
+
+declare class ChatMessageOrchestratorComponent implements OnInit {
+    private orchestrationService;
+    messages: _angular_core.InputSignal<MessageContent[]>;
+    messageRole: _angular_core.InputSignal<ChatRole>;
+    messagesSignal: _angular_core.Signal<MessageContent[]>;
+    ngOnInit(): void;
+    onAudioCompleted(message: MessageContent): void;
+    onWordClicked(wordData: WordData): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatMessageOrchestratorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatMessageOrchestratorComponent, "dc-message-orchestrator", never, { "messages": { "alias": "messages"; "required": true; "isSignal": true; }; "messageRole": { "alias": "messageRole"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DCConversationUserChatSettingsComponent implements OnInit {
+    private dialogRef;
+    private fb;
+    private conversationCardAIService;
+    isLoadingModels: boolean;
+    readonly showFeature: _angular_core.InputSignal<any>;
+    readonly onSettingsChange: _angular_core.OutputEmitterRef<any>;
+    readonly closeClicked: _angular_core.OutputEmitterRef<void>;
+    readonly settingsApplied: _angular_core.OutputEmitterRef<any>;
+    textEngines: TextEngines[];
+    voiceTTSOptions: _dataclouder_ngx_agent_cards.VoiceTTSOption[];
+    textEngineOptions: {
+        value: TextEngines;
+        label: string;
+    }[];
+    speedOptions: {
+        label: AudioSpeed;
+        value: AudioSpeed;
+    }[];
+    modelnames: any[];
+    form: _angular_forms.FormGroup<{
+        synthVoice: _angular_forms.FormControl<boolean>;
+        highlightWords: _angular_forms.FormControl<boolean>;
+        speed: _angular_forms.FormControl<AudioSpeed>;
+        realTime: _angular_forms.FormControl<boolean>;
+        repeatRecording: _angular_forms.FormControl<boolean>;
+        superHearing: _angular_forms.FormControl<boolean>;
+        fixGrammar: _angular_forms.FormControl<boolean>;
+        autoTranslate: _angular_forms.FormControl<boolean>;
+        userMessageTask: _angular_forms.FormControl<boolean>;
+        assistantMessageTask: _angular_forms.FormControl<boolean>;
+        voice: _angular_forms.FormControl<string>;
+        model: _angular_forms.FormGroup<{
+            quality: _angular_forms.FormControl<_dataclouder_ngx_core.EModelQuality>;
+            modelName: _angular_forms.FormControl<string>;
+            provider: _angular_forms.FormControl<string>;
+            id: _angular_forms.FormControl<string>;
+        }>;
+    }>;
+    tooltipRef: TemplateRef<any>;
+    isAdmin: boolean;
+    ngOnInit(): void;
+    private loadInitialSettings;
+    close(): void;
+    saveSettings(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DCConversationUserChatSettingsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DCConversationUserChatSettingsComponent, "dc-chat-settings-dialog", never, { "showFeature": { "alias": "showFeature"; "required": false; "isSignal": true; }; }, { "onSettingsChange": "onSettingsChange"; "closeClicked": "closeClicked"; "settingsApplied": "settingsApplied"; }, never, never, true, never>;
+}
+
+export { AIGenerationService, AgentCardListComponent, AgentCardUI, AudioService, AudioSpeed, CONVERSATION_AI_TOKEN, ChatEventType, ChatMessage, ChatMessageOrchestratorComponent, ChatMonitorService, ChatRole, ConditionOperator, ConditionType, ContextEngineService, ContextType, ConversationDTO, ConversationEvents, ConversationMessagesDTO, ConversationPromptBuilderService, ConversationType$1 as ConversationType, ConversationTypeOptions, DCAgentCardFormComponent, DCChatComponent, DCConversationUserChatSettingsComponent, DcAgentCardDetailsComponent, DefaultAgentCardsService, DoActionTypeOptions, DynamicFlowService, DynamicFlowTaskTypeOptions, EAccountsPlatform, EAgentType, EDoActionType, EDynamicFlowTaskType, EntityThen, EntityWhatOptions, EntityWhenOptions, EvalResultStringDefinition, GlobalToolsService, MOOD_STATE_PROMPT, MessageContent, MessageContentDisplayer, MessagesStateService, ModelSelectorComponent, PopupService, SystemPromptType, TextEngineOptions, TextEngines, USER_DATA_EXCHANGE, UserDataExchangeAbstractService, VoiceTTSOption, VoiceTTSOptions, WordTimestamps, buildObjectTTSRequest, characterCardStringDataDefinition, convertToHTML, createAIModelFormGroup, defaultconvUserSettings, extractAudioAndTranscription, extractJsonFromResponse, getMoodStateLabelsAsString, markdownToHtml, matchTranscription, provideAgentCardService, provideUserDataExchange, removeEmojis, removeEmojisAndSpecialCharacters, removeSpecialCharacters };
+export type { Appearance, AudioGenerated, AudioState, BackgroundTask, ChangePromptAction, CharacterCardData, ChatEvent, ConversationFlowFormGroup, ConversationSettingsFormGroup, DoAction, DoActionFormGroup, DynamicConditionFormGroup, DynamicCriteriaFormGroup, IAccounts, IAgentAssets, IAgentCard, IAgentCardMeta, IAgentMetadata, IAgentResponseDTO, ICharacterCardDC, IConversationFlow, IConversationSettings, IConversationSettingsDTO, IDynamicCondition, IDynamicCriteria, IDynamicFlowTask, ISimpleAgent, ITTS, IWordMetadata, ModelFormGroup, ModelName, SimpleAgentTask, SimpleAgentTaskFormGroup, SimpleEvalResult, TranscriptionsWhisper, TriggerTasksFormGroup, UserDataExchange, VoiceTTS, WordData };