@sinequa/agent 4.0.0

package/index.d.ts

@@ -0,0 +1,2929 @@
+import * as rxjs from 'rxjs';
+import { Subject, Observable, BehaviorSubject } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { Signal, DestroyRef, OnInit, ElementRef, InjectionToken, Type, AfterViewInit } from '@angular/core';
+import * as _ngrx_signals from '@ngrx/signals';
+import * as _sinequa_atomic from '@sinequa/atomic';
+import { Query, Article, Result as Result$2, AuditEvent } from '@sinequa/atomic';
+import * as xstate from 'xstate';
+import * as _sinequa_agent from '@sinequa/agent';
+import * as z from 'zod';
+import * as _angular_common_http from '@angular/common/http';
+import { MessageHeaders, HttpTransportType, ITransport, HubConnectionState, HubConnection, LogLevel } from '@microsoft/signalr';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer } from '@angular/platform-browser';
+import { cn } from '@sinequa/ui';
+import * as _sinequa_atomic_angular from '@sinequa/atomic-angular';
+import * as _tanstack_angular_query_experimental from '@tanstack/angular-query-experimental';
+import * as _tanstack_query_core from '@tanstack/query-core';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import MarkdownIt from 'markdown-it';
+
+/** {@link HttpTransportType} */
+declare const SignalRTransportSchema: z.ZodEnum<{
+    WebSockets: "WebSockets";
+    ServerSentEvents: "ServerSentEvents";
+    LongPolling: "LongPolling";
+    None: "None";
+}>;
+type SignalRTransport = z.infer<typeof SignalRTransportSchema>;
+/** {@link LogLevel} */
+declare const SignalRLogLevelSchema: z.ZodEnum<{
+    None: "None";
+    Trace: "Trace";
+    Debug: "Debug";
+    Information: "Information";
+    Warning: "Warning";
+    Error: "Error";
+    Critical: "Critical";
+}>;
+type SignalRLogLevel = z.infer<typeof SignalRLogLevelSchema>;
+/** @see https://doc-internal.sinequa.com/assistant/latest/app-json-customization#global-settings---globalsettings-object */
+declare const GlobalSettingsSchema: z.ZodObject<{
+    disclaimer: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type GlobalSettings = z.infer<typeof GlobalSettingsSchema>;
+/** @see https://doc-internal.sinequa.com/assistant/latest/app-json-customization#saved-chat---savedchatsettings-object */
+declare const SavedChatSettingsSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    display: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type SavedChatSettings = z.infer<typeof SavedChatSettingsSchema>;
+/** @see https://doc-internal.sinequa.com/assistant/latest/app-json-customization#connection-settings---connectionsettings-object */
+declare const ConnectionSettingsSchema: z.ZodObject<{
+    connectionErrorMessage: z.ZodDefault<z.ZodString>;
+    signalRTransport: z.ZodDefault<z.ZodEnum<{
+        WebSockets: "WebSockets";
+        ServerSentEvents: "ServerSentEvents";
+        LongPolling: "LongPolling";
+        None: "None";
+    }>>;
+    signalRLogLevel: z.ZodDefault<z.ZodEnum<{
+        None: "None";
+        Trace: "Trace";
+        Debug: "Debug";
+        Information: "Information";
+        Warning: "Warning";
+        Error: "Error";
+        Critical: "Critical";
+    }>>;
+    signalRServerTimeoutInMilliseconds: z.ZodDefault<z.ZodNumber>;
+    signalRSkipNegotiation: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type ConnectionSettings = z.infer<typeof ConnectionSettingsSchema>;
+/** @see https://doc-internal.sinequa.com/assistant/latest/app-json-customization#auditSettings */
+declare const AuditSettingsSchema: z.ZodObject<{
+    issueTypes: z.ZodArray<z.ZodString>;
+    logContent: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type AuditSettings = z.infer<typeof AuditSettingsSchema>;
+/** @see */
+declare const AdditionalToolPropertiesSchema: z.ZodObject<{}, z.core.$strip>;
+type AdditionalToolProperties = z.infer<typeof AdditionalToolPropertiesSchema>;
+/** @see https://doc-internal.sinequa.com/assistant/latest/agent-configuration */
+declare const AgentConfigSchema: z.ZodReadonly<z.ZodObject<{
+    defaultAgent: z.ZodString;
+    switchAgents: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    globalSettings: z.ZodObject<{
+        disclaimer: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    connectionSettings: z.ZodObject<{
+        connectionErrorMessage: z.ZodDefault<z.ZodString>;
+        signalRTransport: z.ZodDefault<z.ZodEnum<{
+            WebSockets: "WebSockets";
+            ServerSentEvents: "ServerSentEvents";
+            LongPolling: "LongPolling";
+            None: "None";
+        }>>;
+        signalRLogLevel: z.ZodDefault<z.ZodEnum<{
+            None: "None";
+            Trace: "Trace";
+            Debug: "Debug";
+            Information: "Information";
+            Warning: "Warning";
+            Error: "Error";
+            Critical: "Critical";
+        }>>;
+        signalRServerTimeoutInMilliseconds: z.ZodDefault<z.ZodNumber>;
+        signalRSkipNegotiation: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    savedChatSettings: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        display: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    auditSettings: z.ZodObject<{
+        issueTypes: z.ZodArray<z.ZodString>;
+        logContent: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    additionalToolProperties: z.ZodObject<{}, z.core.$strip>;
+}, z.core.$strip>>;
+type AgentConfig = z.infer<typeof AgentConfigSchema>;
+
+type MessageComponentType = 'user' | 'agent' | 'function' | 'debug';
+type UserFeedback = {
+    type: 'positive' | 'negative';
+    comment?: string;
+};
+type UserFeedbackPositive = UserFeedback & {
+    type: 'positive';
+};
+type UserFeedbackNegative = UserFeedback & {
+    type: 'negative';
+    issueType: string;
+};
+type AdditionalProperties = {
+    display?: boolean;
+    isUserInput?: boolean;
+    $debug?: DebugMessageProperties[];
+    $userFeedback?: UserFeedback;
+};
+type ApplicationContext = {
+    appName: string | undefined;
+    query: Query | undefined;
+};
+type ContextProperties = {
+    language?: {
+        browser: string;
+        sinequaUI: string;
+    };
+    dateTime?: {
+        localISO: string;
+        timezone: string;
+    };
+    urlContext?: {
+        fullUrl: string;
+        pathname: string;
+        searchParams: string;
+    };
+    screenContext?: {
+        width: number;
+        height: number;
+        viewportWidth: number;
+        viewportHeight: number;
+    };
+    specs?: {
+        os: string;
+        browser: string;
+    };
+    applicationContext?: ApplicationContext;
+};
+type ToolChoice = {
+    internalTools?: string[];
+    mcpClients?: {
+        name: string;
+        tools: string[];
+    }[];
+};
+type DebugMessageProperties = {
+    chatId: string;
+    executionId: string;
+    debugMessageId?: string;
+    title?: string;
+    runId?: string;
+    isError?: boolean;
+};
+type DebugMessageGroup = {
+    runId: string;
+    messages: DebugMessageProperties[];
+    expanded: boolean;
+};
+type MessageRole = 'user' | 'assistant' | 'system' | 'tool';
+type MessageType = 'text';
+type MessageContentText = {
+    $type: 'text';
+    text: string;
+};
+type MessageContentImage = {
+    $type: 'image';
+    image: string;
+};
+type MessageContentVideo = {
+    $type: 'video';
+    video: string;
+};
+type MessageContent = MessageContentText | MessageContentImage | MessageContentVideo | MessageContentFunctionCall | MessageContentFunctionResult | MessageContentFunctionApprovalRequest | MessageContentFunctionApprovalResponse;
+type Message = {
+    role: MessageRole;
+    messageId: string;
+    contents: MessageContent[];
+    additionalProperties?: AdditionalProperties;
+    authorName?: string;
+    createdAt?: string;
+};
+type FunctionCall = {
+    callId: string;
+    name: string;
+    toolCardTemplateName?: string;
+    arguments: Record<string, any>;
+    additionalProperties?: Record<string, any>;
+};
+type MessageContentFunctionCall = FunctionCall & {
+    $type: 'functionCall';
+};
+type MessageContentFunctionResult = {
+    $type: 'functionResult';
+    callId: string;
+    result: string | {
+        content: Record<string, any>[];
+    } | Record<string, any>[];
+    executionTime?: string;
+    isError?: boolean;
+    additionalProperties?: Record<string, any>;
+};
+type MessageContentFunctionApprovalRequest = {
+    $type: 'functionApprovalRequest';
+    functionCall: FunctionCall;
+    id: string;
+};
+type MessageContentFunctionApprovalResponse = {
+    $type: 'functionApprovalResponse';
+    approved: boolean;
+    functionCall: FunctionCall;
+    id: string;
+};
+type MessageIdentity = 'user' | 'assistant' | 'functionCall' | 'functionApprovalRequest' | 'functionResult' | 'functionApprovalResponse';
+
+declare const AGENT_ACTION_EVENT_NAME = "agent-action";
+type ActionEvent = {
+    origin: 'agent' | 'user' | 'input';
+    action: MessageAgentAction | MessageUserAction | InputAction;
+};
+/**
+ * copy: user clicked the copy button to copy the message contents
+ * regenerate: user clicked the regenerate button to regenerate from the message
+ * like: user clicked the like button to provide positive feedback
+ * dislike: user clicked the dislike button to provide negative feedback
+ * debug: user clicked the debug button to view debug information
+ * function_approval: user responded to a function approval request with either approval or rejection
+ */
+type MessageAgentAction = 'copy' | 'regenerate' | 'like' | 'dislike' | 'debug' | 'function_approval';
+type MessageAgentActionEvent = ActionEvent & {
+    origin: 'agent';
+    action: MessageAgentAction;
+    message?: Message;
+    callback?: (payload?: object) => void;
+    approvalData?: MessageContentFunctionApprovalResponse;
+};
+declare function isAgentActionEvent(event: ActionEvent): event is MessageAgentActionEvent;
+/**
+ * copy: user clicked the copy button to copy the message contents
+ * edit: user clicked the edit button to edit the message
+ */
+type MessageUserAction = 'copy' | 'edit';
+type MessageUserActionEvent = ActionEvent & {
+    origin: 'user';
+    action: MessageUserAction;
+    message?: Message;
+};
+declare function isUserActionEvent(event: ActionEvent): event is MessageUserActionEvent;
+/**
+ * clear: user clicked the clear button to clear the input
+ * cancel: user clicked the cancel button to cancel editing
+ * stop: user clicked the stop button to stop the agent generation
+ */
+type InputAction = 'clear' | 'cancel' | 'stop';
+type InputActionEvent = ActionEvent & {
+    origin: 'input';
+    action: InputAction;
+};
+declare function isInputActionEvent(event: ActionEvent): event is InputActionEvent;
+type UserActionType = MessageUserActionEvent;
+type AgentActionType = MessageAgentActionEvent;
+type InputActionType = InputActionEvent;
+interface ActionTypeMap {
+    user: UserActionType;
+    agent: AgentActionType;
+    input: InputActionType;
+}
+type ActionTypeKey = keyof ActionTypeMap;
+declare function createActionEvent<T extends ActionTypeKey>(origin: T, action: ActionTypeMap[T]['action'], payload?: Omit<ActionTypeMap[T], 'origin' | 'action'>): CustomEvent<ActionTypeMap[T]>;
+
+declare const ADMIN_EVENT_NAME = "admin";
+type AdminEventId = 'ADMIN_COPIED_AGENT_CONFIG';
+type AdminEventPayload = {
+    status: 'success' | 'failure' | 'info';
+    details?: string;
+};
+type AdminEvent = Partial<AdminEventPayload> & {
+    id: AdminEventId;
+};
+declare function createAdminEvent(id: AdminEventId, payload?: AdminEventPayload): CustomEvent<AdminEvent>;
+
+declare const AGENT_ERROR_EVENT_NAME = "agent-error";
+type AgentErrorId = 'AGENT_FAILED_TO_INVOKE_AGENT' | 'AGENT_FAILED_TO_STOP_GENERATION';
+type AgentErrorEvent = {
+    id: AgentErrorId;
+    error?: any;
+    errorMessage?: string;
+};
+declare function createAgentErrorEvent(id: AgentErrorId, error?: any, errorMessage?: string): CustomEvent<AgentErrorEvent>;
+
+declare const AGENT_EVENT_NAME = "agent";
+type AgentEventId = 'AGENT_STOPPED_GENERATION' | 'COPY_CODE_BLOCK' | 'COPY_TABLE_AS_CSV' | 'DOWNLOAD_TABLE_AS_CSV';
+type AgentEvent = {
+    id: AgentEventId;
+    payload?: any;
+};
+declare function createAgentEvent(id: AgentEventId, payload?: any): CustomEvent<AgentEvent>;
+
+declare global {
+    interface HTMLElementEventMap {
+        [AGENT_ACTION_EVENT_NAME]: CustomEvent<ActionEvent>;
+        [AGENT_ERROR_EVENT_NAME]: CustomEvent<AgentErrorEvent>;
+        [AGENT_EVENT_NAME]: CustomEvent<AgentEvent>;
+    }
+}
+
+declare const AGENT_NEW_CHAT_EVENT_NAME = "agent-new-chat";
+type AgentNewChatEvent = {
+    instanceId: string;
+};
+declare function createAgentNewChatEvent(instanceId: string): CustomEvent<AgentNewChatEvent>;
+
+type BasePayload = {
+    executionTime: string;
+    executionTimeMilliseconds: number;
+    methodresult: string;
+};
+
+type DebugDisplayItemData = {
+    key: string;
+    value: object | string;
+};
+type DebugDisplayItem = {
+    type: 'KV' | 'LIST';
+    isError: boolean;
+};
+type DebugDisplayItemKV = DebugDisplayItem & {
+    type: 'KV';
+    data: DebugDisplayItemData;
+};
+type DebugDisplayItemList = DebugDisplayItem & {
+    type: 'LIST';
+    name: string;
+    items: DebugDisplayItem[];
+};
+type DebugMessage = {
+    debugMessageId: string;
+    dateTimeUtc: string;
+    content: any;
+};
+type DebugMessageListPayload = BasePayload & {
+    debugMessages: DebugMessage[];
+};
+
+/**
+ * Frames are SignalR messages that contain partial or complete data about the agent's response.
+ * They are used to update the UI in real-time as the agent processes a request.
+ */
+/** Message updates */
+type MessageFrame = {
+    delta: string;
+    messageId: string;
+};
+/**
+ * Debug information about current execution, should match {@link DebugMessageProperties}
+ */
+type DebugDisplayFrame = DebugMessageProperties;
+/**
+ * Last frame, contains backend state of current conversation
+ * @see https://doc-internal.sinequa.com/assistant/latest/history-object
+ * @see https://doc-internal.sinequa.com/assistant/latest/signalr-and-rest-streaming-messages#history
+ */
+type HistoryFrame = {
+    executionTime: string;
+    executionTimeMilliseconds: number;
+    history: Message[];
+    title?: string;
+};
+type functionCallFrame = {
+    callId: string;
+    name: string;
+    arguments: Record<string, any>;
+    additionalProperties?: Record<string, any>;
+};
+type functionResultFrame = {
+    callId: string;
+    result: {
+        content: Record<string, any>[];
+    };
+    executionTime: string;
+    executionTimeMilliseconds: number;
+    isError?: boolean;
+    additionalProperties?: Record<string, any>;
+};
+/** Sent by the backend when OAuth authorization is required for an MCP server. */
+type OAuthRequiredFrame = {
+    mcpServerName: string;
+    authorizationUrl: string;
+    state: string;
+    callbackUrl: string;
+};
+type FrameEventName = 'message' | 'history' | 'debugDisplay' | 'functionCall' | 'functionResult' | 'oauthRequired';
+type FrameEventType = MessageFrame | HistoryFrame | DebugDisplayFrame | functionCallFrame | functionResultFrame | OAuthRequiredFrame;
+type FrameEvent = {
+    name: FrameEventName;
+    payload: FrameEventType;
+};
+
+type HistoryContentBase = {
+    type: 'text' | 'image' | 'video';
+};
+type HistoryContent = HistoryContentText | HistoryContentImage | HistoryContentVideo;
+type HistoryContentText = HistoryContentBase & {
+    type: 'text';
+    text: string;
+};
+type HistoryContentImage = HistoryContentBase & {
+    type: 'image';
+    image: string;
+};
+type HistoryContentVideo = HistoryContentBase & {
+    type: 'video';
+    video: string;
+};
+
+type InlineReference = {
+    id: string;
+    offset: number;
+    length: number;
+};
+
+type SavedChatGetPayload = BasePayload & {
+    instanceId: string;
+    savedChat: SavedChat;
+};
+type SavedChatListPayload = BasePayload & {
+    instanceId: string;
+    savedChats: SavedChat[];
+};
+type SavedChatExistsPayload = BasePayload & {
+    exists: boolean;
+};
+type SavedChatAddPayload = BasePayload & {
+    instanceId: string;
+    savedChat: SavedChat;
+};
+type SavedChatUpdatePayload = BasePayload & {
+    instanceId: string;
+    savedChat: SavedChat;
+};
+type SavedChatDeletePayload = BasePayload & {
+    deleteCount: number;
+};
+type SavedChat = {
+    id: string;
+    title: string;
+    modifiedUTC: string;
+    history?: Message[];
+};
+declare enum SavedChatEvent {
+    'add' = 0,
+    'update' = 1,
+    'rename' = 2,
+    'delete' = 3
+}
+declare const SavedChatActions: {
+    add: string;
+    delete: string;
+    exist: string;
+    get: string;
+    list: string;
+    update: string;
+};
+
+interface ConnectionOptions {
+    withCredentials?: boolean;
+    headers?: MessageHeaders;
+    transport?: HttpTransportType | ITransport;
+    skipNegotiation?: boolean;
+    accessTokenFactory?: () => string | Promise<string>;
+}
+/**
+ * Base SignalR events
+ * {@link HubConnectionState}
+ */
+type SignalREventBase = {
+    state: HubConnectionState;
+};
+type SignalREventConnected = SignalREventBase & {
+    state: HubConnectionState.Connected;
+};
+type SignalREventReconnecting = SignalREventBase & {
+    state: HubConnectionState.Reconnecting;
+    retryCount: number;
+    retryDelay: number;
+};
+type SignalREventDisconnected = SignalREventBase & {
+    state: HubConnectionState.Disconnected;
+};
+type SignalREvent = SignalREventConnected | SignalREventReconnecting | SignalREventDisconnected;
+
+type InternalTool = {
+    name: string;
+    description?: string;
+    requiresUserApproval?: boolean;
+};
+type McpTool = {
+    name: string;
+    description?: string;
+    requiresUserApproval?: boolean;
+};
+type McpAuthorizationStatus = 'Granted' | 'NotGranted' | 'Expired';
+type McpClient = {
+    name: string;
+    description?: string;
+    /** SVG markup string for the client's logo, rendered inline. */
+    displaySVGIcon?: string;
+    tools: McpTool[];
+    /** Authorization status returned by the GetAgent endpoint. Absent means no OAuth is required. */
+    authorizationStatus?: McpAuthorizationStatus;
+    /**
+     * Fully-formed OAuth2 authorization URL provided by the backend (already includes `redirect_uri`,
+     * `resource`, and other server-side parameters). The frontend only appends the PKCE parameters.
+     */
+    authorizationUrl?: string;
+};
+type AgentDetails = {
+    name: string;
+    displayName?: string;
+    description?: string;
+    displaySVGIcon?: string;
+    type: string;
+    promptContent?: string;
+    promptTemplateName?: string;
+    historyReducer?: string;
+    runnableModel: {
+        name: string;
+        contextWindowSize?: number;
+    };
+    internalTools?: InternalTool[];
+    mcpClients?: McpClient[];
+    executionSettings?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+
+type Reference = {
+    id: string;
+    metas: {
+        title: string;
+        modified: string;
+        url: string;
+    };
+    chunks: {
+        offset: number;
+        length: number;
+        scores: number[];
+        text: string;
+        chunkTypes: string[];
+    }[];
+    globalRelevanceScore: number;
+};
+
+declare class LoggerService {
+    private readonly instanceId;
+    getFormattedInstanceId: () => string;
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, error?: any): void;
+    errorAndThrow(message: string, error?: any): never;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoggerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LoggerService>;
+}
+
+declare class SavedChatComponent {
+    private readonly destroyRef;
+    private readonly route;
+    private readonly logger;
+    private readonly savedChatsService;
+    searchText: _angular_core.InputSignal<string | undefined>;
+    /** When true, hides the edit and delete actions. */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Emitted when the user clicks on a chat link. */
+    readonly chatSelected: _angular_core.OutputEmitterRef<void>;
+    readonly savedChatsResource: _angular_common_http.HttpResourceRef<_sinequa_agent.SavedChat[]> | undefined;
+    readonly savedChats: _angular_core.Signal<_sinequa_agent.SavedChat[]>;
+    readonly isConnected: _angular_core.Signal<boolean | undefined>;
+    readonly chatId: _angular_core.WritableSignal<string | undefined>;
+    protected readonly hoveredChatId: _angular_core.WritableSignal<string | null>;
+    protected readonly openMenuChatId: _angular_core.WritableSignal<string | null>;
+    private readonly chatMenus;
+    private readonly renamePrompt;
+    private readonly deletePrompt;
+    constructor();
+    renameSavedChat(id: string, currentName: string): Promise<void>;
+    deleteSavedChat(id: string, chatTitle: string): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SavedChatComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SavedChatComponent, "SavedChat,saved-chat,savedchat", never, { "searchText": { "alias": "searchText"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "chatSelected": "chatSelected"; }, never, never, true, never>;
+}
+
+/**
+ * Dialog component that lets the user browse and filter their saved chats.
+ *
+ * Open it programmatically by calling `open()` on a template reference:
+ *
+ * ```html
+ * <saved-chats-dialog #savedChatsDialog />
+ * <button (click)="savedChatsDialog.open()">Open saved chats</button>
+ * ```
+ */
+declare class SavedChatsDialogComponent {
+    private readonly dialogRef;
+    protected readonly searchText: _angular_core.WritableSignal<string | undefined>;
+    protected readonly debouncedSearchText: _angular_core.Signal<string | undefined>;
+    constructor();
+    /** Opens the dialog and resets the search input. */
+    open(): void;
+    /** Closes the dialog programmatically. */
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SavedChatsDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SavedChatsDialogComponent, "SavedChatsDialog,saved-chats-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class SavedChatsService {
+    private readonly http;
+    private readonly instanceId;
+    private readonly agentsStore;
+    private readonly logger;
+    readonly savedChatsEvent: Subject<SavedChatEvent>;
+    /**
+     * Returns an {@link HttpResourceRef} that resolves to the list of saved chats.
+     *
+     * @returns An {@link HttpResourceRef} that resolves to an array of {@link SavedChat}.
+     *
+     * @see https://doc-internal.sinequa.com/assistant/latest/savedchatlist
+     */
+    getSavedChats(searchText: Signal<string | undefined>): _angular_common_http.HttpResourceRef<SavedChat[]>;
+    /**
+     * Returns an {@link HttpResourceRef} that resolves to the {@link SavedChat} identified by `chatId` value.
+     *
+     * @param chatId - The {@link Signal} handling the id of the saved chat to retrieve.
+     * @param storeToDB - Whether to store the chat history in {@link SavedChatsDBService} for future reference (default: true).
+     *
+     * @returns A promise resolving to the {@link SavedChat} identified by `chatId` value.
+     *
+     * @see https://doc-internal.sinequa.com/assistant/latest/savedchatget
+     */
+    getSavedChat(chatId: string | undefined): Promise<SavedChat | undefined>;
+    /**
+     * Checks if a chat with the given `chatId` exists.
+     *
+     * The returned {@link Observable} emits once and completes.
+     *
+     * @param chatId - The id of the chat to check for existence.
+     *
+     * @returns An {@link Observable} that emits a {@link SavedChatExistsPayload}.
+     *
+     * @see https://doc-internal.sinequa.com/assistant/latest/savedchatexist
+     */
+    doesChatExists(chatId: string): Observable<SavedChatExistsPayload>;
+    /**
+     * Saves a new chat with the given `chatId` and `history`.
+     *
+     * The returned {@link Observable} emits once and completes.
+     *
+     * @param chatId - The id of the chat to save.
+     * @param history - The history of the chat to save.
+     * @param title - An optional title for the chat.
+     *
+     * @return An {@link Observable} that emits a {@link SavedChatAddPayload}.
+     *
+     * @see https://doc-internal.sinequa.com/assistant/latest/savedchatadd
+     */
+    saveChat(chatId: string, history: Message[], title?: string): Observable<SavedChatAddPayload>;
+    /**
+     * Updates an existing chat identified by `chatId` with the given `update` object.
+     * The `update` object can contain either or both of `history` and `title` properties.
+     *
+     * The returned {@link Observable} emits once and completes.
+     *
+     * @param chatId - The id of the chat to update.
+     * @param update - An object containing the properties to update: `history` and/or `title`.
+     *
+     * @return An {@link Observable} that emits a {@link SavedChatUpdatePayload}.
+     *
+     * @see https://doc-internal.sinequa.com/assistant/latest/savedchatupdate
+     */
+    updateSavedChat(chatId: string, update: {
+        history?: Message[];
+        title?: string;
+    }): Observable<SavedChatUpdatePayload>;
+    /**
+     * Combination of both save and update methods for chat history, by:
+     * - Calling {@link doesChatExists} to check if the chat already exists
+     * - Calling either {@link saveChat} or {@link updateSavedChat} based on the chat existence
+     *
+     * The returned {@link Observable} emits once and completes.
+     *
+     * @param chatId - The id of the chat to save or update.
+     * @param history - The history of the chat to save or update.
+     * @param title - An optional title for the chat (only used on first save).
+     *
+     * @return An {@link Observable} that emits either a {@link SavedChatAddPayload} or a {@link SavedChatUpdatePayload}.
+     *
+     * @see https://doc-internal.sinequa.com/assistant/latest/savedchatadd
+     * @see https://doc-internal.sinequa.com/assistant/latest/savedchatupdate
+     */
+    upsaveChat(chatId: string, history: Message[], title?: string): Observable<SavedChatAddPayload | SavedChatUpdatePayload>;
+    /**
+     * Deletes the chats identified by the given `chatIds`.
+     *
+     * The returned {@link Observable} emits once and completes.
+     *
+     * @param chatIds - The ids of the chats to delete.
+     *
+     * @return An {@link Observable} that emits a {@link SavedChatDeletePayload}.
+     *
+     * @see https://doc-internal.sinequa.com/assistant/latest/savedchatdelete
+     */
+    deleteSavedChat(chatIds: string[]): Observable<SavedChatDeletePayload>;
+    /**
+     * Chat history is considered valid to be saved if it contains at least one message with:
+     * - role equal to 'user'.
+     * - additionalProperties.isUserInput equal to true.
+     *
+     * @param history - The chat history to check.
+     *
+     * @returns Whether the chat history is considered valid to be saved.
+     */
+    canHistoryBeSaved(history: Message[]): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SavedChatsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SavedChatsService>;
+}
+
+interface SignalRConnectionOperationConfig {
+    webSocketEndpoint: string;
+    agentConfig: AgentConfig;
+}
+declare abstract class ASignalRService {
+    private readonly signalRWebService;
+    private readonly localeId;
+    protected config: SignalRConnectionOperationConfig | undefined;
+    protected connection: HubConnection | undefined;
+    hasConnection: () => boolean;
+    hasOpenedConnection: () => boolean;
+    buildConnectionWithConfig(config: SignalRConnectionOperationConfig, options?: ConnectionOptions): Promise<void>;
+    startConnection(): Promise<void>;
+    stopConnection(): Promise<void>;
+    clearConnection(): void;
+    protected checkConfig(config: SignalRConnectionOperationConfig): void;
+    private getDefaultOptions;
+    private getLogLevel;
+    private getTransports;
+}
+declare class SignalRService extends ASignalRService {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SignalRService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SignalRService>;
+}
+
+/**
+ * A service to connect the Sinequa server to the client via SignalR
+ */
+declare class SignalRWebService {
+    private readonly retryPolicy;
+    private readonly destroyRef;
+    readonly signalREvents$: Subject<SignalREvent>;
+    readonly isConnected$: rxjs.Observable<boolean>;
+    readonly isConnected: _angular_core.Signal<boolean | undefined>;
+    private connectionRetryCount;
+    constructor();
+    /**
+     * Builds a SignalR {@link HubConnection} object and returns it.
+     *
+     * @param endpointName - Name of the endpoint to connect to.
+     * @param options - Options for the connection. It must overrides the default options.
+     * @param logLevel - The log level for the connection.
+     * @param automaticReconnect - Whether the connection should automatically attempt to reconnect.
+     *
+     * @fires `SignalREventReconnecting` - Event attached to the connection that emits when the connection is reconnecting.
+     * @fires `SignalREventConnected` - Event attached to the connection that emits when the connection is connected.
+     * @fires `SignalREventDisconnected` - Event attached to the connection that emits when the connection is disconnected / closed.
+     *
+     * @returns A SignalR HubConnection object.
+     */
+    buildHubConnection(endpointName: string, options: ConnectionOptions, logLevel?: LogLevel, automaticReconnect?: boolean): HubConnection;
+    getNextRetryDelay(): number | null;
+    /**
+     * Starts a SignalR connection.
+     *
+     * @param connection - A SignalR connection.
+     *
+     * @fires `SignalREventConnected` - Event attached to the connection that emits when the connection is connected.
+     *
+     * @throws An error if the connection is undefined.
+     * @throws An error if the connection could not be started.
+     */
+    startConnection(connection: HubConnection | undefined): Promise<void>;
+    /**
+     * Stops a SignalR connection.
+     *
+     * @param connection - A SignalR connection.
+     *
+     * @fires `SignalREventConnected` - Event attached to the connection that emits when the connection is connected.
+     *
+     * @throws An error if the connection is undefined.
+     * @throws An error if the connection could not be stopped.
+     */
+    stopConnection(connection: HubConnection | undefined): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SignalRWebService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SignalRWebService>;
+}
+
+declare class AgentService extends ASignalRService {
+    private readonly instanceId;
+    private readonly agentName;
+    private readonly appStore;
+    private readonly destroyRef;
+    private readonly agentsStore;
+    private readonly logger;
+    readonly afterFrame$: Subject<FrameEvent>;
+    readonly isAgentGenerating: _angular_core.Signal<boolean>;
+    private messageBuilder;
+    private _chatId;
+    private _generatedTitle;
+    get generatedTitle(): string | undefined;
+    get chatId(): string;
+    set chatId(value: string);
+    private _isAgentGenerating;
+    setIsAgentGenerating(value: boolean): void;
+    constructor();
+    buildAgentConnection(): Promise<void>;
+    /**
+     * Starts a new Agent invocation with the provided history.
+     *
+     * @param history - The history to send to the agent.
+     *
+     * @returns A promise that resolves when the history has been sent.
+     */
+    sendHistoryToAgent(history: Message[]): Promise<any>;
+    stopGeneration(): Promise<undefined>;
+    /**
+     * Starts the OAuth2 authorization flow for the given MCP client.
+     *
+     * The backend sends an `OAuthAuthorizationRequired` frame (received via `afterFrame$` as
+     * `'oauthRequired'`) containing the full authorization URL, then waits for the platform
+     * OAuth callback to complete the token exchange. This method resolves once the full flow
+     * finishes — `true` on success, `false` on failure.
+     *
+     * @param mcpServerName - The name of the MCP server to authorize.
+     *
+     * @returns A promise that resolves with `true` on success or `false` on failure.
+     */
+    authorizeRemoteMcp(mcpServerName: string): Promise<boolean>;
+    /**
+     * Revokes the OAuth2 authorization for the given MCP server.
+     * The backend clears the cached token; the `McpAuthorizationRevoked` frame triggers a
+     * details refresh so the UI reflects the updated authorization status.
+     *
+     * @param mcpServerName - The name of the MCP server whose token should be revoked.
+     *
+     * @returns A promise that resolves with `true` on success or `false` on failure.
+     */
+    revokeRemoteMcp(mcpServerName: string): Promise<boolean>;
+    private addAgentFrames;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgentService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AgentService>;
+}
+
+/** Data hold by the agent state machine */
+type AgentMachineContext = {
+    history: Message[];
+    message?: Message;
+    hasSavedChat: boolean;
+    connectionRetryCount: number;
+};
+/** Input to provide at state machine startup */
+type AgentMachineInput = {
+    history: Message[];
+    hasSavedChat: boolean;
+};
+/** State machine events */
+type AgentMachineEvents = {
+    type: 'RETRY_CONNECTION';
+} | {
+    type: 'CONNECTION_LOST';
+} | {
+    type: 'ON_FRAME_HISTORY';
+    history: Message[];
+} | {
+    type: 'LOAD_CHAT';
+} | {
+    type: 'NEW_MESSAGE';
+    message: Message;
+} | {
+    type: 'REGENERATE_MESSAGE';
+    message: Message;
+} | {
+    type: 'EDIT_MESSAGE';
+    message: Message;
+} | {
+    type: 'EDITION_CANCELED';
+} | {
+    type: 'EDITION_VALIDATED';
+    newMessage: Message;
+    oldMessage: Message;
+} | {
+    type: 'PROMPT_USER';
+} | {
+    type: 'PROMPT_FEEDBACK_POSITIVE';
+    message: Message;
+    comment: string;
+} | {
+    type: 'PROMPT_FEEDBACK_NEGATIVE';
+    message: Message;
+    comment: string;
+    issueType: string;
+} | {
+    type: 'PROMPT_REJECTED';
+} | {
+    type: 'APPROVAL_PROVIDED';
+    message: Message;
+} | {
+    type: 'STOP_GENERATION';
+};
+/**
+ * Base class for Agent components, providing state machine functionality.
+ *
+ * @remarks
+ * This class isn't marked as abstract to allow Angular DI to work properly.
+ * Extend this class to create specific Agent components.
+ * Do not instantiate this class directly.
+ */
+declare class Machine {
+    protected readonly inspectXState: boolean | null;
+    protected readonly instanceId: string;
+    protected readonly agentService: AgentService;
+    protected readonly agentsStore: {
+        ready: _angular_core.Signal<boolean>;
+        savedChatReady: _angular_core.Signal<boolean>;
+        debugMessages: _angular_core.Signal<boolean>;
+        referenceCache: _angular_core.Signal<Record<string, Reference>>;
+        agentDetails: _angular_core.Signal<_sinequa_agent.AgentDetails | undefined>;
+        agentDetailsLoading: _angular_core.Signal<boolean>;
+        toolChoice: _angular_core.Signal<_sinequa_agent.ToolChoice | undefined>;
+        setReady: (ready: boolean) => void;
+        setSavedChatReady: (ready: boolean) => void;
+        getAgentInstanceConfiguration: (instanceId: string) => z.core.output<typeof AgentConfigSchema> | undefined;
+        setDebugMessages: (debug: boolean) => void;
+        setReferences: (references: Record<string, Reference>) => void;
+        addReference: (reference: Reference) => void;
+        addReferences: (references: Record<string, Reference>) => void;
+        getReferenceMetas: (id: string) => Reference["metas"] | undefined;
+        getAgentDetails: (name: string) => void;
+        updateAgentDetails: (name: string) => void;
+        reloadAgentDetails: () => void;
+        updateToolChoice: (toolChoice: _sinequa_agent.ToolChoice) => void;
+    } & _ngrx_signals.WritableStateSource<{
+        ready: boolean;
+        savedChatReady: boolean;
+        debugMessages: boolean;
+        referenceCache: Record<string, Reference>;
+        agentDetails: _sinequa_agent.AgentDetails | undefined;
+        agentDetailsLoading: boolean;
+        toolChoice: _sinequa_agent.ToolChoice | undefined;
+    }>;
+    protected readonly logger: LoggerService;
+    protected readonly savedChatsService: SavedChatsService | null;
+    protected readonly destroyRef: DestroyRef;
+    readonly inputChatId: _angular_core.InputSignal<string | undefined>;
+    protected readonly chatId: _angular_core.WritableSignal<string | undefined>;
+    protected readonly isReady: _angular_core.Signal<boolean>;
+    protected readonly afterHistoryFrame$: rxjs.Observable<HistoryFrame>;
+    protected readonly config: _angular_core.WritableSignal<Readonly<{
+        defaultAgent: string;
+        switchAgents: string[];
+        globalSettings: {
+            disclaimer: string;
+        };
+        connectionSettings: {
+            connectionErrorMessage: string;
+            signalRTransport: "WebSockets" | "ServerSentEvents" | "LongPolling" | "None";
+            signalRLogLevel: "None" | "Trace" | "Debug" | "Information" | "Warning" | "Error" | "Critical";
+            signalRServerTimeoutInMilliseconds: number;
+            signalRSkipNegotiation: boolean;
+        };
+        auditSettings: {
+            issueTypes: string[];
+            logContent: boolean;
+        };
+        additionalToolProperties: Record<string, never>;
+        savedChatSettings?: {
+            enabled: boolean;
+            display: boolean;
+        } | undefined;
+    }> | undefined>;
+    protected readonly state: _angular_core.WritableSignal<string | undefined>;
+    protected agentActor: xstate.Actor<xstate.StateMachine<AgentMachineContext, {
+        type: "RETRY_CONNECTION";
+    } | {
+        type: "CONNECTION_LOST";
+    } | {
+        type: "ON_FRAME_HISTORY";
+        history: Message[];
+    } | {
+        type: "LOAD_CHAT";
+    } | {
+        type: "NEW_MESSAGE";
+        message: Message;
+    } | {
+        type: "REGENERATE_MESSAGE";
+        message: Message;
+    } | {
+        type: "EDIT_MESSAGE";
+        message: Message;
+    } | {
+        type: "EDITION_CANCELED";
+    } | {
+        type: "EDITION_VALIDATED";
+        newMessage: Message;
+        oldMessage: Message;
+    } | {
+        type: "PROMPT_USER";
+    } | {
+        type: "PROMPT_FEEDBACK_POSITIVE";
+        message: Message;
+        comment: string;
+    } | {
+        type: "PROMPT_FEEDBACK_NEGATIVE";
+        message: Message;
+        comment: string;
+        issueType: string;
+    } | {
+        type: "PROMPT_REJECTED";
+    } | {
+        type: "APPROVAL_PROVIDED";
+        message: Message;
+    } | {
+        type: "STOP_GENERATION";
+    }, {
+        [x: string]: xstate.ActorRefFromLogic<xstate.PromiseActorLogic<void, xstate.NonReducibleUnknown, xstate.EventObject>> | xstate.ActorRefFromLogic<xstate.PromiseActorLogic<Message[], xstate.NonReducibleUnknown, xstate.EventObject>> | xstate.ActorRefFromLogic<xstate.PromiseActorLogic<unknown, xstate.NonReducibleUnknown, xstate.EventObject>> | xstate.ActorRefFromLogic<xstate.PromiseActorLogic<undefined, xstate.NonReducibleUnknown, xstate.EventObject>> | undefined;
+    }, {
+        src: "validateAgentConfiguration";
+        logic: xstate.PromiseActorLogic<void, xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    } | {
+        src: "startConnection";
+        logic: xstate.PromiseActorLogic<void, xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    } | {
+        src: "loadSavedChat";
+        logic: xstate.PromiseActorLogic<Message[], xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    } | {
+        src: "upsaveChat";
+        logic: xstate.PromiseActorLogic<unknown, xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    } | {
+        src: "sendHistoryToAgent";
+        logic: xstate.PromiseActorLogic<unknown, xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    } | {
+        src: "stopGeneration";
+        logic: xstate.PromiseActorLogic<undefined, xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    }, {
+        type: "sliceHistoryFromMessageId";
+        params: unknown;
+    } | {
+        type: "raiseEvent";
+        params: {
+            type: string;
+        };
+    } | {
+        type: "incrementConnectionRetryCount";
+        params: unknown;
+    } | {
+        type: "resetConnectionRetryCount";
+        params: unknown;
+    } | {
+        type: "setupChatId";
+        params: unknown;
+    } | {
+        type: "injectFeedbackIntoMessage";
+        params: {
+            action: "positive" | "negative";
+        };
+    } | {
+        type: "updateAgentGeneratingStatus";
+        params: {
+            value: boolean;
+        };
+    }, {
+        type: "canRetryToConnect";
+        params: unknown;
+    } | {
+        type: "hasSavedChat";
+        params: unknown;
+    } | {
+        type: "approvalRequired";
+        params: unknown;
+    }, never, "CheckingAgentConfiguration" | "Connecting" | "ConfigurationIsInvalid" | "RetryToConnect" | "Disconnected" | {
+        Connected: "AgentProcessing" | "Initialize" | "SavedChatLoaded" | "Idle" | "WaitingForApproval" | "Editing" | "PromptingUser" | "EditionValidated" | "EditionCanceled" | "TryUpsaveChat" | "StoppingGeneration" | "UpsaveChat" | "EndOfInteraction" | "FailedToSaveChat";
+    }, string, AgentMachineInput, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
+        id: "AgentMachine";
+        states: {
+            readonly CheckingAgentConfiguration: {};
+            readonly ConfigurationIsInvalid: {};
+            readonly Connecting: {};
+            readonly RetryToConnect: {};
+            readonly Disconnected: {};
+            readonly Connected: {
+                states: {
+                    readonly Initialize: {};
+                    readonly SavedChatLoaded: {};
+                    readonly Idle: {};
+                    readonly Editing: {};
+                    readonly EditionValidated: {};
+                    readonly EditionCanceled: {};
+                    readonly PromptingUser: {};
+                    readonly WaitingForApproval: {};
+                    readonly AgentProcessing: {};
+                    readonly StoppingGeneration: {};
+                    readonly TryUpsaveChat: {};
+                    readonly UpsaveChat: {};
+                    readonly FailedToSaveChat: {};
+                    readonly EndOfInteraction: {};
+                };
+            };
+        };
+    }>>;
+    private actorSubscription;
+    protected readonly machine: xstate.StateMachine<AgentMachineContext, {
+        type: "RETRY_CONNECTION";
+    } | {
+        type: "CONNECTION_LOST";
+    } | {
+        type: "ON_FRAME_HISTORY";
+        history: Message[];
+    } | {
+        type: "LOAD_CHAT";
+    } | {
+        type: "NEW_MESSAGE";
+        message: Message;
+    } | {
+        type: "REGENERATE_MESSAGE";
+        message: Message;
+    } | {
+        type: "EDIT_MESSAGE";
+        message: Message;
+    } | {
+        type: "EDITION_CANCELED";
+    } | {
+        type: "EDITION_VALIDATED";
+        newMessage: Message;
+        oldMessage: Message;
+    } | {
+        type: "PROMPT_USER";
+    } | {
+        type: "PROMPT_FEEDBACK_POSITIVE";
+        message: Message;
+        comment: string;
+    } | {
+        type: "PROMPT_FEEDBACK_NEGATIVE";
+        message: Message;
+        comment: string;
+        issueType: string;
+    } | {
+        type: "PROMPT_REJECTED";
+    } | {
+        type: "APPROVAL_PROVIDED";
+        message: Message;
+    } | {
+        type: "STOP_GENERATION";
+    }, {
+        [x: string]: xstate.ActorRefFromLogic<xstate.PromiseActorLogic<void, xstate.NonReducibleUnknown, xstate.EventObject>> | xstate.ActorRefFromLogic<xstate.PromiseActorLogic<Message[], xstate.NonReducibleUnknown, xstate.EventObject>> | xstate.ActorRefFromLogic<xstate.PromiseActorLogic<unknown, xstate.NonReducibleUnknown, xstate.EventObject>> | xstate.ActorRefFromLogic<xstate.PromiseActorLogic<undefined, xstate.NonReducibleUnknown, xstate.EventObject>> | undefined;
+    }, {
+        src: "validateAgentConfiguration";
+        logic: xstate.PromiseActorLogic<void, xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    } | {
+        src: "startConnection";
+        logic: xstate.PromiseActorLogic<void, xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    } | {
+        src: "loadSavedChat";
+        logic: xstate.PromiseActorLogic<Message[], xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    } | {
+        src: "upsaveChat";
+        logic: xstate.PromiseActorLogic<unknown, xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    } | {
+        src: "sendHistoryToAgent";
+        logic: xstate.PromiseActorLogic<unknown, xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    } | {
+        src: "stopGeneration";
+        logic: xstate.PromiseActorLogic<undefined, xstate.NonReducibleUnknown, xstate.EventObject>;
+        id: string | undefined;
+    }, {
+        type: "sliceHistoryFromMessageId";
+        params: unknown;
+    } | {
+        type: "raiseEvent";
+        params: {
+            type: string;
+        };
+    } | {
+        type: "incrementConnectionRetryCount";
+        params: unknown;
+    } | {
+        type: "resetConnectionRetryCount";
+        params: unknown;
+    } | {
+        type: "setupChatId";
+        params: unknown;
+    } | {
+        type: "injectFeedbackIntoMessage";
+        params: {
+            action: "positive" | "negative";
+        };
+    } | {
+        type: "updateAgentGeneratingStatus";
+        params: {
+            value: boolean;
+        };
+    }, {
+        type: "canRetryToConnect";
+        params: unknown;
+    } | {
+        type: "hasSavedChat";
+        params: unknown;
+    } | {
+        type: "approvalRequired";
+        params: unknown;
+    }, never, "CheckingAgentConfiguration" | "Connecting" | "ConfigurationIsInvalid" | "RetryToConnect" | "Disconnected" | {
+        Connected: "AgentProcessing" | "Initialize" | "SavedChatLoaded" | "Idle" | "WaitingForApproval" | "Editing" | "PromptingUser" | "EditionValidated" | "EditionCanceled" | "TryUpsaveChat" | "StoppingGeneration" | "UpsaveChat" | "EndOfInteraction" | "FailedToSaveChat";
+    }, string, AgentMachineInput, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
+        id: "AgentMachine";
+        states: {
+            readonly CheckingAgentConfiguration: {};
+            readonly ConfigurationIsInvalid: {};
+            readonly Connecting: {};
+            readonly RetryToConnect: {};
+            readonly Disconnected: {};
+            readonly Connected: {
+                states: {
+                    readonly Initialize: {};
+                    readonly SavedChatLoaded: {};
+                    readonly Idle: {};
+                    readonly Editing: {};
+                    readonly EditionValidated: {};
+                    readonly EditionCanceled: {};
+                    readonly PromptingUser: {};
+                    readonly WaitingForApproval: {};
+                    readonly AgentProcessing: {};
+                    readonly StoppingGeneration: {};
+                    readonly TryUpsaveChat: {};
+                    readonly UpsaveChat: {};
+                    readonly FailedToSaveChat: {};
+                    readonly EndOfInteraction: {};
+                };
+            };
+        };
+    }>;
+    constructor();
+    getChatId(): string | undefined;
+    /**
+     * Updates the Agent machine context with the received history frame.
+     *
+     * @param history - History frame received from SignalR.
+     */
+    protected onHistory(history: HistoryFrame): void;
+    /** Listen to state changes from the XState actor and propagate them to the state signal. */
+    private listenToStateChanges;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Machine, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Machine, "abstract-agent-machine", never, { "inputChatId": { "alias": "chatId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class Agent extends Machine {
+    private readonly el;
+    private readonly parentEl;
+    private readonly mainEl;
+    private readonly principalStore;
+    readonly principal: _ngrx_signals.DeepSignal<_sinequa_atomic.Principal>;
+    readonly firstName: _angular_core.Signal<any>;
+    private readonly messageList;
+    private readonly chatInput;
+    private readonly like;
+    private readonly dislike;
+    protected readonly message: _angular_core.WritableSignal<Message | undefined>;
+    protected readonly history: _angular_core.WritableSignal<Message[] | undefined>;
+    protected readonly reportedMessage: _angular_core.WritableSignal<Message | undefined>;
+    protected readonly isUiLocked: _angular_core.WritableSignal<boolean>;
+    protected readonly afterMessageFrame$: rxjs.Observable<MessageFrame>;
+    private pendingApprovalResponses;
+    constructor();
+    getHistory(): Message[] | undefined;
+    /**
+     * Handles the start of a new chat session.
+     * @param event The event triggering the new chat.
+     * @returns void
+     */
+    private startNewChat;
+    /**
+     * Binds event handlers to the agent actor's state machine events.
+     *
+     * This method sets up listeners for various state machine events and maps them to appropriate
+     * handler functions that manage UI state, message list operations, and error handling.
+     *
+     * The following events are handled:
+     * - `PROMPT_USER_ENTER`: Locks the UI when prompting the user
+     * - `PROMPT_USER_EXIT`: Unlocks the UI when prompt is dismissed
+     * - `CLEAR_MESSAGE_LIST_FROM`: Regenerates messages from a specific message ID
+     * - `AGENT_INVOCATION_FAILED`: Dispatches an error event when agent invocation fails
+     * - `EDITION_STARTED`: Locks messages and populates chat input for editing
+     * - `EDITION_COMPLETED`: Clears locked messages after successful edit
+     * - `EDITION_ABORTED`: Unlocks messages and cancels chat input on edit cancellation
+     * - `SAVED_CHAT_LOADED`: Updates the history state when a saved chat is loaded
+     * - `APPROVAL_MODE_ENTER`: Enters approval mode, clears pending approvals if any, and locks the UI
+     * - `APPROVAL_MODE_EXIT`: Exits approval mode, unlocks the UI, and clears pending approvals
+     * - `AGENT_STOPPED_GENERATION`: Generation was successfully stopped.
+     * - `AGENT_FAILED_TO_STOP_GENERATION`: Generation failed to stop.
+     *
+     * @private
+     */
+    private bindMachineEvents;
+    /**
+     * Handles custom events emitted by child components.
+     * @param event - The custom event containing action details.
+     */
+    private customEventSwitch;
+    private handleFeedbackPrompts;
+    /**
+     * Handles the function approval response by storing it and checking if all pending approvals have been responded to.
+     * @param data - The approval response data received
+     */
+    private handleApprovalResponse;
+    /**
+     * Handles user sent text.
+     * @param text - The user input text.
+     */
+    protected userValidatedInput(text: string): void;
+    /**
+     * Updates the UI with the received message frame.
+     * @param message - Message frame received from SignalR.
+     */
+    private onMessage;
+    private initResizeObserver;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Agent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Agent, "Agent,agent", never, {}, {}, never, never, true, never>;
+}
+
+declare class AgentInjector implements OnInit {
+    private readonly injector;
+    private readonly viewContainer;
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly store;
+    readonly instanceId: _angular_core.InputSignal<string>;
+    readonly chatId: _angular_core.InputSignal<string | undefined>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgentInjector, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgentInjector, "AgentInjector,agent-injector,agentinjector", never, { "instanceId": { "alias": "instanceId"; "required": true; "isSignal": true; }; "chatId": { "alias": "chatId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MessageBuilder {
+    private _message;
+    constructor(message?: Message | undefined);
+    getMessage(): Message | undefined;
+    clear(): void;
+    createUserMessage(text: string): void;
+    createAgentMessage(): void;
+    createFunctionApprovalResponseMessage(): void;
+    setMessageId(messageId: string): void;
+    setMessageContextFromHistoryFrame(historyFrame: HistoryFrame): void;
+    setContent(content: MessageContent[]): void;
+    appendContent(content: MessageContent): void;
+    appendDebugMessageFrame(debugMessage: DebugMessageProperties): void;
+    private setAdditionalProperties;
+}
+
+declare class CopyableFieldComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly copyResult: _angular_core.OutputEmitterRef<{
+        field: string;
+        status: "success" | "failure";
+    }>;
+    private readonly copyState;
+    protected readonly copied: _angular_core.Signal<boolean>;
+    copy(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopyableFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopyableFieldComponent, "copyable-field", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; }, { "copyResult": "copyResult"; }, never, never, true, never>;
+}
+
+/**
+ * Handles the OAuth2 redirect callback.
+ *
+ * This component should be registered at the `/oauth-callback` route in the consuming application:
+ * ```ts
+ * { path: 'oauth-callback', component: OAuthCallbackComponent }
+ * ```
+ *
+ * On load it reads the `code` query parameter and posts it back to the opener window
+ * via `postMessage`, then closes itself.
+ */
+declare class OAuthCallbackComponent implements OnInit {
+    private readonly route;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OAuthCallbackComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OAuthCallbackComponent, "oauth-callback", never, {}, {}, never, never, true, never>;
+}
+
+declare class AdminDirective {
+    private readonly el;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AdminDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AdminDirective, "[admin]", never, {}, {}, never, never, true, never>;
+}
+
+declare class AgentGenerationDirective {
+    private readonly el;
+    private t;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgentGenerationDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AgentGenerationDirective, "[agentGeneration]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CopyToClipboardDirective {
+    private readonly el;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopyToClipboardDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CopyToClipboardDirective, "[copyToClipboard]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ErrorDirective {
+    private readonly el;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ErrorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ErrorDirective, "[error]", never, {}, {}, never, never, true, never>;
+}
+
+declare class FeedbackDirective {
+    private readonly el;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FeedbackDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FeedbackDirective, "[feedback]", never, {}, {}, never, never, true, never>;
+}
+
+declare class InfoPanelComponent {
+    protected readonly instanceId: string;
+    private readonly agentName;
+    protected readonly agentsStore: {
+        ready: _angular_core.Signal<boolean>;
+        savedChatReady: _angular_core.Signal<boolean>;
+        debugMessages: _angular_core.Signal<boolean>;
+        referenceCache: _angular_core.Signal<Record<string, Reference>>;
+        agentDetails: _angular_core.Signal<_sinequa_agent.AgentDetails | undefined>;
+        agentDetailsLoading: _angular_core.Signal<boolean>;
+        toolChoice: _angular_core.Signal<_sinequa_agent.ToolChoice | undefined>;
+        setReady: (ready: boolean) => void;
+        setSavedChatReady: (ready: boolean) => void;
+        getAgentInstanceConfiguration: (instanceId: string) => z.infer<typeof _sinequa_agent.AgentConfigSchema> | undefined;
+        setDebugMessages: (debug: boolean) => void;
+        setReferences: (references: Record<string, Reference>) => void;
+        addReference: (reference: Reference) => void;
+        addReferences: (references: Record<string, Reference>) => void;
+        getReferenceMetas: (id: string) => Reference["metas"] | undefined;
+        getAgentDetails: (name: string) => void;
+        updateAgentDetails: (name: string) => void;
+        reloadAgentDetails: () => void;
+        updateToolChoice: (toolChoice: _sinequa_agent.ToolChoice) => void;
+    } & _ngrx_signals.WritableStateSource<{
+        ready: boolean;
+        savedChatReady: boolean;
+        debugMessages: boolean;
+        referenceCache: Record<string, Reference>;
+        agentDetails: _sinequa_agent.AgentDetails | undefined;
+        agentDetailsLoading: boolean;
+        toolChoice: _sinequa_agent.ToolChoice | undefined;
+    }>;
+    private readonly principal;
+    private readonly md;
+    readonly chatId: _angular_core.InputSignal<string | undefined>;
+    protected readonly isAdminOrDelegatedAdmin: _angular_core.Signal<boolean>;
+    constructor();
+    private readonly sanitizer;
+    protected readonly renderedPrompt: _angular_core.Signal<string>;
+    protected readonly icon: _angular_core.Signal<_angular_platform_browser.SafeHtml | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfoPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InfoPanelComponent, "InfoPanel,info-panel,infopanel", never, { "chatId": { "alias": "chatId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare enum ChatInputMode {
+    Default = "default",
+    Edit = "edit"
+}
+declare class ChatInput {
+    cn: typeof cn;
+    private readonly principal;
+    private readonly agentsStore;
+    protected readonly menuMinWidth: _angular_core.Signal<"clamp(300px, 80vw, 500px)" | "clamp(200px, 80vw, 300px)">;
+    private readonly el;
+    protected readonly isConnected: _angular_core.Signal<boolean | undefined>;
+    protected readonly agentName: string;
+    private readonly textInput;
+    readonly chatId: _angular_core.InputSignal<string | undefined>;
+    readonly class: _angular_core.InputSignal<string | undefined>;
+    readonly variant: _angular_core.InputSignal<"default" | "primary" | "secondary" | "destructive" | "ai" | null | undefined>;
+    readonly decoration: _angular_core.InputSignal<"none" | "outline" | null | undefined>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly value: _angular_core.OutputEmitterRef<string>;
+    protected readonly text: _angular_core.ModelSignal<string>;
+    protected readonly showCancel: _angular_core.WritableSignal<boolean>;
+    protected readonly canStopGeneration: _angular_core.WritableSignal<boolean>;
+    readonly isAdminOrDelegatedAdmin: _angular_core.Signal<boolean>;
+    protected readonly variants: _angular_core.Signal<string>;
+    protected readonly canSend: _angular_core.Signal<boolean | undefined>;
+    protected readonly displayName: _angular_core.Signal<string>;
+    submit(event?: Event): void;
+    edit(text: string): void;
+    cancel(): void;
+    protected dispatchEvent(action: InputAction, payload?: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatInput, "ChatInput,chat-input,chatinput", never, { "chatId": { "alias": "chatId"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "decoration": { "alias": "decoration"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "value": "value"; "text": "textChange"; }, never, never, true, never>;
+}
+
+type DialogState = 'info' | 'waiting';
+/**
+ * Modal dialog for connecting an MCP client via OAuth2.
+ *
+ * Displays MCP client information and manages the two-phase OAuth flow:
+ * 1. Info state — shows the client name/description and a Connect button.
+ * 2. Waiting state — shows a spinner/message while the user authenticates in the external tab.
+ *
+ * Opens itself automatically when mounted. Emits `connected` on successful auth
+ * and `cancelled` when the user dismisses or cancels.
+ */
+declare class McpConnectDialogComponent {
+    private readonly agentService;
+    private readonly destroyRef;
+    /** The MCP client to authorize. */
+    readonly client: _angular_core.InputSignal<McpClient>;
+    /** Emitted after a successful OAuth authorization. */
+    readonly connected: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the user cancels or closes the dialog without completing auth. */
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    private readonly dialogRef;
+    protected readonly state: _angular_core.WritableSignal<DialogState>;
+    private closedByOutcome;
+    constructor();
+    protected connect(): Promise<void>;
+    protected cancelAndClose(): void;
+    protected onDialogClose(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<McpConnectDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<McpConnectDialogComponent, "mcp-connect-dialog", never, { "client": { "alias": "client"; "required": true; "isSignal": true; }; }, { "connected": "connected"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+declare class McpServerItemComponent {
+    readonly name: _angular_core.InputSignal<string>;
+    readonly panelId: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    readonly functions: _angular_core.InputSignal<McpTool[] | undefined>;
+    readonly isOpen: _angular_core.InputSignal<boolean>;
+    readonly toggled: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<McpServerItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<McpServerItemComponent, "mcp-server-item", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "panelId": { "alias": "panelId"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "functions": { "alias": "functions"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "toggled": "toggled"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class AvailableInternalToolsComponent {
+    readonly agentDetails: _angular_core.InputSignal<AgentDetails>;
+    readonly selectable: _angular_core.InputSignal<boolean>;
+    readonly showHeading: _angular_core.InputSignal<boolean>;
+    readonly selectedTools: _angular_core.ModelSignal<string[]>;
+    protected readonly internalTools: _angular_core.Signal<_sinequa_agent.InternalTool[]>;
+    private readonly selectedSet;
+    protected toggleTool(name: string): void;
+    protected isToolSelected(name: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvailableInternalToolsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvailableInternalToolsComponent, "AvailableInternalTools,available-internal-tools,availableinternaltools", never, { "agentDetails": { "alias": "agentDetails"; "required": true; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "showHeading": { "alias": "showHeading"; "required": false; "isSignal": true; }; "selectedTools": { "alias": "selectedTools"; "required": false; "isSignal": true; }; }, { "selectedTools": "selectedToolsChange"; }, never, never, true, never>;
+}
+
+declare class AvailableMcpServersComponent {
+    private readonly agentService;
+    readonly agentDetails: _angular_core.InputSignal<AgentDetails>;
+    readonly selectable: _angular_core.InputSignal<boolean>;
+    readonly showHeading: _angular_core.InputSignal<boolean>;
+    readonly selectedMcpClients: _angular_core.ModelSignal<{
+        name: string;
+        tools: string[];
+    }[]>;
+    protected readonly openMcpCard: _angular_core.WritableSignal<string | null>;
+    protected readonly connectingClient: _angular_core.WritableSignal<McpClient | null>;
+    protected readonly confirmingRevokeClient: _angular_core.WritableSignal<McpClient | null>;
+    protected readonly revokingClient: _angular_core.WritableSignal<string | null>;
+    protected readonly mcpClients: _angular_core.Signal<McpClient[]>;
+    private readonly selectedNames;
+    protected isGranted(client: McpClient): boolean;
+    protected toggleMcpCard(key: string): void;
+    protected toggleClient(client: McpClient): void;
+    protected isClientSelected(clientName: string): boolean;
+    protected onConnected(client: McpClient): void;
+    protected onRevokeConfirmed(client: McpClient): Promise<void>;
+    protected revokeClient(client: McpClient): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvailableMcpServersComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvailableMcpServersComponent, "AvailableMcpServers,available-mcp-servers,availablemcpservers", never, { "agentDetails": { "alias": "agentDetails"; "required": true; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "showHeading": { "alias": "showHeading"; "required": false; "isSignal": true; }; "selectedMcpClients": { "alias": "selectedMcpClients"; "required": false; "isSignal": true; }; }, { "selectedMcpClients": "selectedMcpClientsChange"; }, never, never, true, never>;
+}
+
+declare class ToolsSelectionPanelComponent {
+    private readonly agentName;
+    protected readonly agentsStore: {
+        ready: _angular_core.Signal<boolean>;
+        savedChatReady: _angular_core.Signal<boolean>;
+        debugMessages: _angular_core.Signal<boolean>;
+        referenceCache: _angular_core.Signal<Record<string, Reference>>;
+        agentDetails: _angular_core.Signal<AgentDetails | undefined>;
+        agentDetailsLoading: _angular_core.Signal<boolean>;
+        toolChoice: _angular_core.Signal<_sinequa_agent.ToolChoice | undefined>;
+        setReady: (ready: boolean) => void;
+        setSavedChatReady: (ready: boolean) => void;
+        getAgentInstanceConfiguration: (instanceId: string) => z.infer<typeof _sinequa_agent.AgentConfigSchema> | undefined;
+        setDebugMessages: (debug: boolean) => void;
+        setReferences: (references: Record<string, Reference>) => void;
+        addReference: (reference: Reference) => void;
+        addReferences: (references: Record<string, Reference>) => void;
+        getReferenceMetas: (id: string) => Reference["metas"] | undefined;
+        getAgentDetails: (name: string) => void;
+        updateAgentDetails: (name: string) => void;
+        reloadAgentDetails: () => void;
+        updateToolChoice: (toolChoice: _sinequa_agent.ToolChoice) => void;
+    } & _ngrx_signals.WritableStateSource<{
+        ready: boolean;
+        savedChatReady: boolean;
+        debugMessages: boolean;
+        referenceCache: Record<string, Reference>;
+        agentDetails: AgentDetails | undefined;
+        agentDetailsLoading: boolean;
+        toolChoice: _sinequa_agent.ToolChoice | undefined;
+    }>;
+    readonly chatId: _angular_core.InputSignal<string | undefined>;
+    protected readonly selectedInternalTools: _angular_core.WritableSignal<string[]>;
+    protected readonly selectedMcpClients: _angular_core.WritableSignal<{
+        name: string;
+        tools: string[];
+    }[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolsSelectionPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToolsSelectionPanelComponent, "ToolsSelectionPanel,tools-selection-panel,toolsselectionpanel", never, { "chatId": { "alias": "chatId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * This class allows {@link MessageList} to keep track of any instantiated message component,
+ * and calls their {@link ComponentRef.destroy} lifecycle hooks when {@link MessageList} needs to be cleared.
+ */
+declare abstract class MessageBaseComponent {
+    protected readonly el: ElementRef<any>;
+    abstract getMessageId(): string | undefined;
+    abstract getType(): MessageComponentType;
+    protected dispatchEvent(event: CustomEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageBaseComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageBaseComponent, "abstract-base-message", never, {}, {}, never, never, true, never>;
+}
+
+declare class MessageService {
+    readonly stream$: BehaviorSubject<Message | undefined>;
+    readonly debugStream$: BehaviorSubject<DebugMessageProperties | undefined>;
+    next(message: Message): void;
+    nextDebug(debug: DebugMessageProperties): void;
+    complete(): void;
+    completeDebug(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MessageService>;
+}
+
+declare class MessageAgentComponent extends MessageBaseComponent {
+    private readonly messageService;
+    readonly message: _angular_core.WritableSignal<Message | undefined>;
+    readonly done: _angular_core.WritableSignal<boolean>;
+    readonly showToolbar: _angular_core.WritableSignal<boolean>;
+    readonly showDebugPanel: _angular_core.WritableSignal<boolean>;
+    readonly showDebugButton: _angular_core.WritableSignal<boolean>;
+    /**
+     * When true, the toolbar is not rendered. Used by MessageList to suppress the toolbar
+     * on intermediate text segments, repositioning it below tool/approval cards instead.
+     */
+    readonly hideToolbar: _angular_core.InputSignal<boolean>;
+    /**
+     * When true, the text content is not rendered. Used by MessageList to insert a
+     * toolbar-only ghost component after tool/approval cards — the component carries
+     * the message data for copy/regenerate actions without duplicating visible text.
+     */
+    readonly hideContent: _angular_core.InputSignal<boolean>;
+    /**
+     * Character offset into the flattened text. The backend accumulates all streamed text
+     * into a single growing string; when a tool call splits the stream mid-turn, the next
+     * visual component skips the already-displayed prefix by slicing from this offset.
+     * Set to 0 (default) when no split occurred.
+     */
+    readonly textOffset: _angular_core.InputSignal<number>;
+    readonly messageId: _angular_core.WritableSignal<string | undefined>;
+    readonly flattenedContent: _angular_core.Signal<string>;
+    readonly feedback: _angular_core.WritableSignal<"positive" | "negative" | undefined>;
+    constructor();
+    getService(): MessageService;
+    getMessageId(): string | undefined;
+    getType(): MessageComponentType;
+    messageAction(event: MessageAgentActionEvent): void;
+    debugMessage(): void;
+    dispatchMessageAction(action: MessageAgentAction, includeMessage?: boolean): void;
+    feedbackCallback(payload?: object): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageAgentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageAgentComponent, "MessageAgent,message-agent,messageagent", never, { "hideToolbar": { "alias": "hideToolbar"; "required": false; "isSignal": true; }; "hideContent": { "alias": "hideContent"; "required": false; "isSignal": true; }; "textOffset": { "alias": "textOffset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MessageAgentToolbar {
+    protected readonly agentService: AgentService;
+    readonly showDebugButton: _angular_core.InputSignal<boolean>;
+    readonly feedback: _angular_core.InputSignal<"positive" | "negative" | undefined>;
+    readonly action: _angular_core.OutputEmitterRef<MessageAgentActionEvent>;
+    readonly hasPositiveFeedback: _angular_core.Signal<boolean>;
+    readonly hasNegativeFeedback: _angular_core.Signal<boolean>;
+    readonly hasFeedback: _angular_core.Signal<boolean>;
+    copyMessageToClipboard(): void;
+    regenerateMessage(): void;
+    likeMessage(): void;
+    dislikeMessage(): void;
+    debugMessage(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageAgentToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageAgentToolbar, "MessageAgentToolbar,message-agent-toolbar,messageagenttoolbar", never, { "showDebugButton": { "alias": "showDebugButton"; "required": false; "isSignal": true; }; "feedback": { "alias": "feedback"; "required": false; "isSignal": true; }; }, { "action": "action"; }, never, never, true, never>;
+}
+
+declare class DebugService {
+    private readonly http;
+    /**
+     * Returns an {@link Observable} that emits the debug messages identified by `chatId`, `executionId` and `debugMessageId`.
+     *
+     * The returned {@link Observable} emits once and completes.
+     *
+     * @param chatId - The id of the chat.
+     * @param executionId - The id of the execution.
+     * @param debugMessageId - The id of the debug message.
+     *
+     * @returns An {@link Observable} that emits a {@link DebugMessageListPayload}.
+     *
+     * @see https://doc-internal.sinequa.com/assistant/latest/debugmessagelist
+     */
+    getDebugMessages(chatId: string, executionId: string, debugMessageId: string): Observable<_sinequa_agent.BasePayload & {
+        debugMessages: _sinequa_agent.DebugMessage[];
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DebugService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DebugService>;
+}
+
+declare class MessageDebugComponent extends MessageBaseComponent {
+    private readonly messageService;
+    private readonly agent;
+    readonly messageId: _angular_core.InputSignal<string | undefined>;
+    readonly debugMessages: _angular_core.WritableSignal<DebugMessageProperties[]>;
+    readonly groups: _angular_core.Signal<{
+        runId: string;
+        messages: DebugMessageProperties[];
+        expanded: boolean;
+    }[]>;
+    private readonly groupStateMap;
+    getService(): MessageService;
+    constructor();
+    getMessageId(): string | undefined;
+    getType(): MessageComponentType;
+    toggleGroup(group: DebugMessageGroup): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageDebugComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageDebugComponent, "MessageDebug,message-debug,messagedebug", never, { "messageId": { "alias": "messageId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MessageDebugDetailsComponent {
+    private readonly debugMessageService;
+    readonly message: _angular_core.InputSignal<DebugMessageProperties | undefined>;
+    readonly details: _angular_core.WritableSignal<DebugMessage[]>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageDebugDetailsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageDebugDetailsComponent, "MessageDebugDetails,message-debug-details,messagedebugdetails", never, { "message": { "alias": "message"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MessageDebugEntryComponent {
+    readonly message: _angular_core.InputSignal<DebugMessageProperties>;
+    readonly opened: _angular_core.WritableSignal<boolean>;
+    onToggle(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageDebugEntryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageDebugEntryComponent, "MessageDebugEntry,message-debug-entry,messagedebugentry", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MessageDebugKVComponent {
+    readonly row: _angular_core.InputSignal<DebugDisplayItemKV>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageDebugKVComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageDebugKVComponent, "MessageDebugKV,message-debug-kv,messagedebugkv", never, { "row": { "alias": "row"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MessageDebugListComponent {
+    readonly content: _angular_core.InputSignal<DebugDisplayItemList>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageDebugListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageDebugListComponent, "MessageDebugList,message-debug-list,messagedebuglist", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type FunctionData$2 = {
+    call: MessageContentFunctionCall;
+    result?: MessageContentFunctionResult;
+    approved?: boolean;
+};
+declare class MessageFunctionComponent extends MessageBaseComponent {
+    protected readonly showApprovalButtons: _angular_core.Signal<boolean>;
+    protected readonly isError: _angular_core.Signal<boolean>;
+    protected readonly argumentEntries: _angular_core.Signal<[string, any][]>;
+    protected readonly cardClass: _angular_core.Signal<"bg-tool-card border-tool-card-border hover:bg-tool-card-hovered" | "bg-red-100/10 border-stroke-destructive-base" | "bg-destructive-lightest border-stroke-destructive-muted hover:bg-red-100">;
+    protected readonly approvalState: _angular_core.Signal<"approved" | "rejected" | null>;
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    readonly functionData: _angular_core.WritableSignal<FunctionData$2 | undefined>;
+    protected readonly pendingApproval: _angular_core.WritableSignal<boolean>;
+    protected readonly isErrorOpen: _angular_core.WritableSignal<boolean>;
+    /** Auto-opens when approval is pending; can also be toggled by the user. */
+    protected readonly isNormalOpen: _angular_core.WritableSignal<boolean>;
+    getMessageId(): string | undefined;
+    getType(): MessageComponentType;
+    /**
+     * Handles function call content and updates the component state to display the function call information.
+     * @param content - The function call content.
+     */
+    call(content: MessageContentFunctionCall): void;
+    /**
+     * Handles function result content and updates the component state to display the function result information.
+     * @param result - The function result content.
+     */
+    result(result: MessageContentFunctionResult): void;
+    /**
+     * Handles function approval request content and updates the component state to display the approval request information.
+     * @param content - The function approval request content.
+     */
+    approvalRequest(content: MessageContentFunctionApprovalRequest): void;
+    /**
+     * Handles function approval response content, updates the component state to reflect the approval decision,
+     * and hides the pending approval state (buttons).
+     * @param content - The function approval response content.
+     */
+    approvalResponse(content: MessageContentFunctionApprovalResponse): void;
+    /**
+     * Handles the user's response to a function approval request,
+     * dispatches an event with the approval decision,
+     * and updates the component state accordingly.
+     * @param approved - The user's approval decision.
+     */
+    protected answerApprovalRequest(approved: boolean): void;
+    /** Toggles the open/closed state of the card based on its current type. */
+    protected toggleOpen(): void;
+    private dispatchApprovalAction;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageFunctionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageFunctionComponent, "MessageFunction,message-function,messagefunction", never, {}, {}, never, never, true, never>;
+}
+
+type Arguments$1 = {
+    document_id: string;
+    chunk_offset: number;
+    chunk_length: number;
+    strategy: string;
+};
+type Result$1 = {
+    context: string;
+    error: string;
+}[];
+type FunctionData$1 = {
+    call: MessageContentFunctionCall & {
+        arguments: Arguments$1;
+    };
+    result?: MessageContentFunctionResult & {
+        result: Result$1;
+    };
+    approved: boolean;
+};
+declare class ReadDocumentFunctionComponent extends MessageFunctionComponent {
+    functionData: _angular_core.WritableSignal<FunctionData$1 | undefined>;
+    private readonly agentsStore;
+    readonly documentReference: _angular_core.Signal<Reference | undefined>;
+    readonly displayTitle: _angular_core.Signal<string>;
+    result(result: MessageContentFunctionResult): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReadDocumentFunctionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ReadDocumentFunctionComponent, "ReadDocumentFunction, read-document-function", never, {}, {}, never, never, true, never>;
+}
+
+type SearchContext = {
+    id: string;
+    contextDocuments: ContextDocument[];
+    queries: null;
+    resultPage: number;
+    resultPageSize: number;
+    totalMatchingDocumentCount: number;
+    totalDocumentCount: number;
+    hasRelevance: boolean;
+    sort: string;
+    totalTokenCount: number | null;
+    textTokens: number | null;
+    imagesTokens: number | null;
+    metaTokens: number | null;
+};
+type ContextDocument = {
+    id: string;
+    metas: ContextDocumentMeta;
+    chunks: ContextDocumentChunk[];
+    totalTokenCount: number | null;
+    textTokens: number | null;
+    imagesTokens: number | null;
+    metaTokens: number | null;
+    globalRelevanceScore: number | null;
+    documentTotalLength: number | null;
+};
+type ContextDocumentMeta = {
+    id: string;
+    title: string | null;
+    url: string | null;
+    summary: string | null;
+    date: string | null;
+};
+type ContextDocumentChunk = {
+    offset: number;
+    length: number;
+    score: number;
+    scores?: number[];
+    text: string;
+    chunkType: number;
+    chunkTypes?: string[];
+    totalTokenCount: number | null;
+    textTokens: number | null;
+    imagesTokens: number | null;
+};
+
+declare class DocumentCardComponent {
+    private readonly domSanitizer;
+    readonly selectionStore: {
+        article?: _angular_core.Signal<Article | undefined> | undefined;
+        id?: _angular_core.Signal<string | undefined> | undefined;
+        queryText?: _angular_core.Signal<string | undefined> | undefined;
+        queryName?: _angular_core.Signal<string | undefined> | undefined;
+        previewHighlights?: _angular_core.Signal<_sinequa_atomic_angular.PreviewHighlights | undefined> | undefined;
+        assistantIdsToAttach: _angular_core.Signal<string[]>;
+        multiSelection: _angular_core.Signal<Article[]>;
+        multiSelectCount: _angular_core.Signal<number>;
+        update: (newState: Partial<_sinequa_atomic_angular.SelectionState>) => void;
+        clear: () => void;
+        addArticleToMultiSelection: (article: Article) => void;
+        removeArticleFromMultiSelection: (article: Article) => void;
+        clearMultiSelection: () => void;
+    } & _ngrx_signals.StateSource<{
+        article?: Article | undefined;
+        id?: string | undefined;
+        queryText?: string | undefined;
+        queryName?: string | undefined;
+        previewHighlights?: _sinequa_atomic_angular.PreviewHighlights | undefined;
+        assistantIdsToAttach: string[];
+        multiSelection: Article[];
+    }>;
+    /** Most complete: agent answer document with typed metas and chunks. */
+    readonly document: _angular_core.InputSignal<ContextDocument | undefined>;
+    /** Sinequa query result with matching passages and highlighted text. */
+    readonly article: _angular_core.InputSignal<Article | undefined>;
+    /** Lightweight reference from the agent cache, title and date only. */
+    readonly reference: _angular_core.InputSignal<Reference | undefined>;
+    readonly title: _angular_core.Signal<string | undefined>;
+    readonly date: _angular_core.Signal<string | undefined>;
+    readonly segments: _angular_core.Signal<string[]>;
+    readonly summary: _angular_core.Signal<string | null | undefined>;
+    readonly sanitizedSummary: _angular_core.Signal<_angular_platform_browser.SafeHtml>;
+    readonly matchCount: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DocumentCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DocumentCardComponent, "DocumentCard, document-card, documentcard", never, { "document": { "alias": "document"; "required": false; "isSignal": true; }; "article": { "alias": "article"; "required": false; "isSignal": true; }; "reference": { "alias": "reference"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SearchExpansionService {
+    readonly context: _angular_core.WritableSignal<SearchContext | undefined>;
+    readonly queryText: _angular_core.WritableSignal<string | undefined>;
+    readonly expandedCallId: _angular_core.WritableSignal<string | undefined>;
+    readonly isExpanded: _angular_core.Signal<boolean>;
+    expand(context: SearchContext, queryText: string, callId: string): void;
+    collapse(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchExpansionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SearchExpansionService>;
+}
+
+type Arguments = {
+    searchQuery: string;
+};
+type Result = {
+    searchContext: string;
+}[];
+type FunctionData = {
+    call: MessageContentFunctionCall & {
+        arguments: Arguments;
+    };
+    result?: MessageContentFunctionResult & {
+        result: Result;
+    };
+    approved: boolean;
+};
+declare class SearchFunctionComponent extends MessageFunctionComponent {
+    functionData: _angular_core.WritableSignal<FunctionData | undefined>;
+    private readonly agentsStore;
+    protected readonly searchExpansion: SearchExpansionService;
+    /** True only when THIS specific search widget is the one currently expanded. */
+    readonly isExpandedInPanel: _angular_core.Signal<boolean>;
+    readonly searchContext: _angular_core.Signal<SearchContext | undefined>;
+    result(result: MessageContentFunctionResult): void;
+    /**
+     * Normalizes the raw result value into an array of records.
+     * Handles both the live-session format (already an array) and the saved-history
+     * format where the backend may serialize the array as a JSON string.
+     */
+    private toResultArray;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchFunctionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchFunctionComponent, "SearchFunction, search-function, searchfunction", never, {}, {}, never, never, true, never>;
+}
+
+type R = Result$2 & {
+    nextPage?: number;
+    previousPage?: number;
+};
+/**
+ * Shared tabs component for displaying search results in both the inline search
+ * widget (`SearchFunctionComponent`) and the expanded panel (`ExpandedSearchResultsComponent`).
+ *
+ * Inputs:
+ *   - `context`   — the SearchContext holding the top documents to display
+ *   - `queryText` — used for the paginated "More" query
+ *   - `compact`   — when true, constrains the list height (inline widget); when false,
+ *                   fills available space (expanded panel)
+ */
+declare class SearchResultsTabsComponent {
+    protected readonly cn: typeof cn;
+    readonly context: _angular_core.InputSignal<SearchContext>;
+    readonly queryText: _angular_core.InputSignal<string>;
+    readonly compact: _angular_core.InputSignal<boolean>;
+    private readonly queryService;
+    readonly allowSearch: _angular_core.WritableSignal<boolean>;
+    readonly query: _tanstack_angular_query_experimental.CreateInfiniteQueryResult<_tanstack_query_core.InfiniteData<R, unknown>, Error>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchResultsTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchResultsTabsComponent, "SearchResultsTabs,search-results-tabs", never, { "context": { "alias": "context"; "required": true; "isSignal": true; }; "queryText": { "alias": "queryText"; "required": true; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Displays expanded search results in a dedicated panel outside the chat flow.
+ *
+ * Intended for use in host applications (e.g. agent-app) that implement a multi-panel
+ * layout. This component is placed in a dedicated resizable panel alongside the chat and
+ * document preview panels. It is shown when the user clicks "expand" on a search result
+ * inside the chat, which triggers `SearchExpansionService.expand()`.
+ *
+ * Usage:
+ *   <ExpandedSearchResults (close)="onClose()" />
+ *
+ * The component reads its context entirely from `SearchExpansionService` (injected globally),
+ * so no inputs are required. It emits a `close` event when the user dismisses the panel;
+ * the host is responsible for calling `SearchExpansionService.collapse()` in response.
+ *
+ * Tabs:
+ *   - "Top Results": the `contextDocuments` already retrieved by the search tool call.
+ *   - "More": lazy-loaded via `@defer`, triggers a paginated search using `QueryService`
+ *     with infinite scroll once the user navigates to that tab.
+ */
+declare class ExpandedSearchResultsComponent {
+    /** Emitted when the user clicks the close button. The host must call SearchExpansionService.collapse(). */
+    readonly close: _angular_core.OutputEmitterRef<void>;
+    protected readonly store: SearchExpansionService;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExpandedSearchResultsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExpandedSearchResultsComponent, "ExpandedSearchResults,expanded-search-results", never, {}, { "close": "close"; }, never, never, true, never>;
+}
+
+declare class MessageList {
+    private readonly el;
+    private readonly viewContainer;
+    private readonly logger;
+    private readonly agentService;
+    private readonly destroyRef;
+    private readonly agentsStore;
+    private readonly toolCardPlugins;
+    readonly chatId: _angular_core.InputSignal<string | undefined>;
+    readonly message: _angular_core.InputSignal<Message | undefined>;
+    readonly history: _angular_core.InputSignal<Message[] | undefined>;
+    protected readonly isReady: _angular_core.Signal<boolean>;
+    protected readonly hasDebugFeature: _angular_core.Signal<boolean>;
+    private lastMessage;
+    private lastMessageComponent;
+    private lastMessageDebug;
+    private readonly messageComponents;
+    private readonly functionComponents;
+    private messageRenderers;
+    /**
+     * Text offset pending for the next MessageAgentComponent to be created.
+     * Set when a functionCall frame interrupts a live stream: it snapshots the character
+     * length of the already-displayed text so the continuation component can slice it off,
+     * avoiding visual duplication. Consumed immediately on the next component creation.
+     */
+    private nextTextOffset;
+    constructor();
+    /**
+     * Returns the list of message ids
+     * @returns - List of message ids
+     */
+    getMessageIds(): (string | undefined)[];
+    /**
+     * Locks all messages from the message with the given messageId (inclusive).
+     *
+     * @param messageId - The messageId from which to lock messages.
+     *
+     * @remarks This method sets a 'locked' data attribute to 'true' on all message components.
+     * @remarks This method is designed to be called from the parent component.
+     */
+    lockFromMessageId(messageId: string | undefined): void;
+    /**
+     * Unlocks all messages.
+     *
+     * @remarks This method sets a 'locked' data attribute to 'false' on all message components.
+     * @remarks This method is designed to be called from the parent component.
+     */
+    unlockMessages(): void;
+    /**
+     * Removes all locked messages from the message list and UI.
+     */
+    clearLockedMessages(): void;
+    /**
+     * Removes messages from the message list and UI starting from the given messageId (inclusive).
+     *
+     * @param messageId - The messageId from which to clear messages.
+     */
+    regenerateFromMessageId(messageId: string | undefined): void;
+    /**
+     * Initializes the message renderers for different message identities. Each renderer is responsible for rendering a specific type of message based on its identity.
+     * The renderers are stored in the `messageRenderers` object, which maps message identities to their respective rendering functions.
+     * This method is called in the constructor to set up the renderers when the component is initialized.
+     */
+    private initMessageRenderers;
+    /**
+     * Centralized frame handling to route different frame events to their respective handlers.
+     * @param frame - The frame event to handle.
+     */
+    private handleFrame;
+    /**
+     * Clears message from a given index by calling `component.destroy()`
+     * @param index - Index to start deletion from
+     */
+    private clearFromMessageIndex;
+    /** Effect function to watch over history changes */
+    private watchHistory;
+    /** Effect function to watch over message changes */
+    private watchMessage;
+    /**
+     * Clears all messages from the message list and UI.
+     */
+    private clearMessages;
+    /**
+     * Injects the given messages from the history into the message list and the UI.
+     *
+     * @param history - The history to inject.
+     */
+    private injectHistory;
+    /**
+     * Detaches the signal from the last message component, if any.
+     */
+    private detachLastMessageSignal;
+    /**
+     * Injects a new message into the message list and the UI.
+     * @param message - The new message to inject.
+     */
+    private injectNewMessage;
+    /**
+     * Append user message at the end of the message component list, user message is considered
+     * to be the first stable message and act as an "anchor" for the agent turn.
+     * @param message - Message object
+     */
+    private appendMessageUser;
+    /**
+     * Insert agent message above debug message component and allow the debug button to be shown.
+     * @param message - Message object
+     */
+    private insertMessageAgent;
+    /**
+     * Insert function call component(s) in message component list.
+     * @param payload - Content with function call, which will be used to create function component(s) and insert into the message list.
+     */
+    private insertFunctionCallComponent;
+    /**
+     * Select Angular component type to render the function call based on the tool's
+     * toolCardTemplateName, falling back to the function name.
+     * Defaults to MessageFunctionComponent if no matching plugin found.
+     * The value `_default_tool_template` explicitly means "use the default template".
+     */
+    private selectFunctionComponentType;
+    /**
+     * Inject function result into corresponding function call component.
+     * @param payload - Content with function result, which will be used to find the matching function call component and inject the function result into it.
+     */
+    private insertFunctionResult;
+    /**
+     * Insert function approval request message above debug message component
+     * The function component(s) will be created from the content of the message and inserted into the message list.
+     * @param message - Message object with function approval request content.
+     */
+    private insertMessageFunctionApprovalRequest;
+    /**
+     * Update function approval component with response message
+     * The function component(s) will be updated based on the content of the message.
+     * @param message - Message object with function approval response content.
+     */
+    private insertMessageFunctionApprovalResponse;
+    /**
+     * Append debug message component at the bottom of the DOM and the message component list.
+     * @param message - Message object
+     */
+    private appendMessageDebugComponent;
+    /**
+     * Insert component above debug message component in both the DOM and the message component list.
+     * @param component - Message component to be inserted
+     */
+    private insertMessageComponentAboveDebug;
+    /**
+     * Handle the raising debug button click and open the next debug message in the DOM if any.
+     * @param event - CustomEvent object
+     */
+    private onDebugPanelClick;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageList, "MessageList,message-list,messagelist", never, { "chatId": { "alias": "chatId"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "history": { "alias": "history"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MessageUserComponent extends MessageBaseComponent {
+    readonly message: _angular_core.InputSignal<Message>;
+    readonly showToolbar: _angular_core.WritableSignal<boolean>;
+    readonly messageId: _angular_core.Signal<string>;
+    readonly messageContent: _angular_core.Signal<_sinequa_agent.MessageContent[]>;
+    readonly flattenedContent: _angular_core.Signal<string>;
+    getMessageId(): string | undefined;
+    getType(): MessageComponentType;
+    messageAction(event: MessageUserActionEvent): void;
+    dispatchMessageAction(action: MessageUserAction, includeMessage?: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageUserComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageUserComponent, "MessageUser,message-user,messageuser", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MessageUserToolbar {
+    protected readonly agentService: AgentService;
+    readonly action: _angular_core.OutputEmitterRef<MessageUserActionEvent>;
+    copyMessageToClipboard(): void;
+    editMessage(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageUserToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageUserToolbar, "MessageUserToolbar,message-user-toolbar,messageusertoolbar", never, {}, { "action": "action"; }, never, never, true, never>;
+}
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "none" | "primary" | "outline" | "secondary" | "accent" | "destructive" | "ghost" | "icon" | "ai" | null | undefined;
+    decoration?: "none" | "outline" | "underline" | null | undefined;
+    size?: "default" | "icon" | "xs" | "sm" | "lg" | "xl" | "icon-xs" | "icon-sm" | "icon-lg" | "icon-xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariants = VariantProps<typeof buttonVariants>;
+declare class ButtonComponent {
+    class: _angular_core.InputSignal<string | undefined>;
+    variant: _angular_core.InputSignal<"default" | "link" | "none" | "primary" | "outline" | "secondary" | "accent" | "destructive" | "ghost" | "icon" | "ai" | null | undefined>;
+    decoration: _angular_core.InputSignal<"none" | "outline" | "underline" | null | undefined>;
+    size: _angular_core.InputSignal<"default" | "icon" | "xs" | "sm" | "lg" | "xl" | "icon-xs" | "icon-sm" | "icon-lg" | "icon-xl" | null | undefined>;
+    variants: _angular_core.Signal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonComponent, "button", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "decoration": { "alias": "decoration"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const hyperlinkVariants: (props?: ({
+    variant?: "default" | "none" | "primary" | "ghost" | null | undefined;
+    decoration?: "none" | "underline" | null | undefined;
+    layer?: "none" | "disabled" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type HyperlinkVariants = VariantProps<typeof hyperlinkVariants>;
+declare class HyperlinkComponent {
+    class: _angular_core.InputSignal<string | undefined>;
+    variant: _angular_core.InputSignal<"default" | "none" | "primary" | "ghost" | null | undefined>;
+    decoration: _angular_core.InputSignal<"none" | "underline" | null | undefined>;
+    layer: _angular_core.InputSignal<"none" | "disabled" | null | undefined>;
+    variants: _angular_core.Signal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HyperlinkComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HyperlinkComponent, "a", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "decoration": { "alias": "decoration"; "required": false; "isSignal": true; }; "layer": { "alias": "layer"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CastToDebugKVPipe {
+    transform(item: any): DebugDisplayItemKV;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CastToDebugKVPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CastToDebugKVPipe, "castToDebugKV", true>;
+}
+
+declare class CastToDebugListPipe {
+    transform(item: any): DebugDisplayItemList;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CastToDebugListPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CastToDebugListPipe, "castToDebugList", true>;
+}
+
+declare class SafeHtmlPipe {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(html: any): _angular_platform_browser.SafeHtml;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", true>;
+}
+
+/**
+ * A token used to inject the instanceId to be used by all components and services of the Agent.
+ * @see https://doc-internal.sinequa.com/assistant/latest/app-json-customization#sinequa-assistant-instance-settings
+ */
+declare const AGENT_INSTANCE_ID: InjectionToken<string>;
+/**
+ * A token used to inject the default agent name.
+ */
+declare const AGENT_DEFAULT_NAME: InjectionToken<string>;
+/**
+ * A token used to enable the XState inspector for debugging state machines.
+ * @see https://stately.ai/docs/inspector
+ */
+declare const INSPECT_XSTATE: InjectionToken<boolean>;
+/**
+ * Markdown-it plugins are functions that take the markdown-it instance and optional parameters.
+ */
+type MarkdownItPlugin = (md: MarkdownIt, ...params: any[]) => void;
+/**
+ * Renderer plugin defines a markdown-it plugin along with an
+ * optional the Angular component used to render the content.
+ */
+type RendererPlugins = {
+    [key: string]: {
+        markdownItPlugin: MarkdownItPlugin;
+        component?: Type<any> | undefined;
+    };
+};
+/**
+ * A token used to provide markdown-it plugins
+ * @defaultValue {}
+ */
+declare const AGENT_RENDERER_PLUGINS: InjectionToken<RendererPlugins>;
+/**
+ * A token used to provide Angular components for rendering tool cards in Agent messages.
+ * The key is the tool name, and the value is the Angular component used to render the tool card.
+ */
+type ToolCardPlugins = {
+    [key: string]: Type<MessageFunctionComponent>;
+};
+/**
+ * A token to provide Angular components for rendering tool cards in Agent messages.
+ * @defaultValue {}
+ */
+declare const AGENT_TOOL_CARD_PLUGINS: InjectionToken<ToolCardPlugins>;
+
+/**
+ * Configuration for Shiki syntax highlighter
+ */
+type ShikiThemeMode = 'light' | 'dark';
+interface ShikiConfig {
+    langs: string[];
+    themes: Record<ShikiThemeMode, string>;
+}
+declare const SHIKI_HIGHLIGHTER_CONFIG: InjectionToken<ShikiConfig>;
+
+/**
+ * The default retry delays (in milliseconds) for SignalR automatic reconnect.
+ */
+declare const SIGNALR_RETRY_DELAYS: InjectionToken<number[]>;
+declare const SIGNALR_RETRY_DELAYS_DEFAULT: number[];
+
+/**
+ * Factory function to provide renderer plugins.
+ *
+ * @param plugins - renderer plugins to provide
+ *
+ * @returns environment providers
+ */
+declare const provideRendererPlugins: (plugins: RendererPlugins) => _angular_core.EnvironmentProviders;
+/**
+ * Provides default Agent renderer plugins.
+ *
+ * Includes:
+ *   - code block with custom component
+ *   - link with target and rel attributes
+ *   - table tools with custom component
+ *
+ * @returns environment providers
+ */
+declare const provideDefaultRendererPlugins: () => _angular_core.EnvironmentProviders;
+
+type InstanceState = {
+    instanceId: string;
+    configuration: AgentConfig;
+};
+type AgentsState = {
+    ready: boolean;
+    savedChatReady: boolean;
+};
+type DebugState = {
+    debugMessages: boolean;
+};
+type AgentDetailsState = {
+    agentDetails: AgentDetails | undefined;
+    agentDetailsLoading: boolean;
+    toolChoice: ToolChoice | undefined;
+};
+declare const AgentsStore: _angular_core.Type<{
+    ready: _angular_core.Signal<boolean>;
+    savedChatReady: _angular_core.Signal<boolean>;
+    debugMessages: _angular_core.Signal<boolean>;
+    referenceCache: _angular_core.Signal<Record<string, Reference>>;
+    agentDetails: _angular_core.Signal<AgentDetails | undefined>;
+    agentDetailsLoading: _angular_core.Signal<boolean>;
+    toolChoice: _angular_core.Signal<ToolChoice | undefined>;
+    setReady: (ready: boolean) => void;
+    setSavedChatReady: (ready: boolean) => void;
+    getAgentInstanceConfiguration: (instanceId: string) => z.infer<typeof AgentConfigSchema> | undefined;
+    setDebugMessages: (debug: boolean) => void;
+    setReferences: (references: Record<string, Reference>) => void;
+    addReference: (reference: Reference) => void;
+    addReferences: (references: Record<string, Reference>) => void;
+    getReferenceMetas: (id: string) => Reference["metas"] | undefined;
+    getAgentDetails: (name: string) => void;
+    updateAgentDetails: (name: string) => void;
+    reloadAgentDetails: () => void;
+    updateToolChoice: (toolChoice: ToolChoice) => void;
+} & _ngrx_signals.WritableStateSource<{
+    ready: boolean;
+    savedChatReady: boolean;
+    debugMessages: boolean;
+    referenceCache: Record<string, Reference>;
+    agentDetails: AgentDetails | undefined;
+    agentDetailsLoading: boolean;
+    toolChoice: ToolChoice | undefined;
+}>>;
+declare function withAgentsFeatures(): _ngrx_signals.SignalStoreFeature<_ngrx_signals.EmptyFeatureResult, {
+    state: {
+        ready: boolean;
+        savedChatReady: boolean;
+    };
+    props: {};
+    methods: {
+        setReady: (ready: boolean) => void;
+        setSavedChatReady: (ready: boolean) => void;
+        getAgentInstanceConfiguration: (instanceId: string) => z.infer<typeof AgentConfigSchema> | undefined;
+    };
+}>;
+declare function withDebugFeatures(): _ngrx_signals.SignalStoreFeature<_ngrx_signals.EmptyFeatureResult, {
+    state: {
+        debugMessages: boolean;
+    };
+    props: {};
+    methods: {
+        setDebugMessages: (debug: boolean) => void;
+    };
+}>;
+declare function withAgentDetailsFeatures(): _ngrx_signals.SignalStoreFeature<_ngrx_signals.EmptyFeatureResult, {
+    state: {
+        agentDetails: AgentDetails | undefined;
+        agentDetailsLoading: boolean;
+        toolChoice: ToolChoice | undefined;
+    };
+    props: {};
+    methods: {
+        getAgentDetails: (name: string) => void;
+        updateAgentDetails: (name: string) => void;
+        reloadAgentDetails: () => void;
+        updateToolChoice: (toolChoice: ToolChoice) => void;
+    };
+}>;
+
+/**
+ * Factory function to provide the SavedChatsService only if enabled in the agent configuration.
+ *
+ * @param instanceId - The agent instance ID.
+ * @param logger - Logger service for logging messages.
+ * @param agentsStore - The agents store to access agent configurations.
+ *
+ * @returns An instance of {@link SavedChatsService} if enabled, otherwise `undefined`.
+ *
+ * @see https://doc-internal.sinequa.com/assistant/latest/app-json-customization#saved-chat---savedchatsettings-object
+ */
+declare function provideSavedChatsService(instanceId: string, logger: LoggerService, agentsStore: InstanceType<typeof AgentsStore>): SavedChatsService | undefined;
+
+/**
+ * Creates environment providers for Shiki syntax highlighter configuration.
+ *
+ * @param config - The Shiki configuration object containing highlighter settings
+ * @returns An array of environment providers that can be used in the application configuration
+ */
+declare const provideShikiHighlighterConfig: (config: ShikiConfig) => _angular_core.EnvironmentProviders;
+/**
+ * Provides the default Shiki syntax highlighter configuration with commonly used programming languages and themes.
+ *
+ * @remarks
+ * This configuration includes support for web technologies (HTML, CSS, JavaScript/TypeScript),
+ * data formats (JSON, CSV, XML), and other common languages (Python, Markdown, SQL).
+ * It uses GitHub's light and dark themes with light as the default.
+ *
+ * @returns A configured Shiki highlighter provider with predefined languages and themes.
+ */
+declare const provideDefaultShikiHighlighterConfig: () => _angular_core.EnvironmentProviders;
+
+/**
+ * Factory function to provide tool card plugins.
+ *
+ * @param plugins - tool card plugins to provide
+ *
+ * @returns environment providers
+ */
+declare const provideToolCardPlugins: (plugins: ToolCardPlugins) => _angular_core.EnvironmentProviders;
+/**
+ * Provides default Agent tool card plugins.
+ *
+ * @returns environment providers
+ */
+declare const provideDefaultToolCardPlugins: () => _angular_core.EnvironmentProviders;
+
+declare class AgentConfigurationService {
+    private readonly http;
+    /**
+     * Retrieve the agent configuration from the backend.
+     *
+     * @param name - The name of the agent to retrieve the configuration for.
+     *
+     * @returns An observable emitting the agent configuration.
+     */
+    getAgent(name: string, contextProperties?: ContextProperties): rxjs.Observable<AgentDetails>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgentConfigurationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AgentConfigurationService>;
+}
+
+type AgentAuditType = 'agent.report.positive.click' | 'agent.report.negative.click' | 'agent.report.positive.submit' | 'agent.report.negative.submit';
+declare class AuditService {
+    private readonly instanceId;
+    private readonly agentName;
+    private readonly principal;
+    createAuditObject(type: AgentAuditType, chatId: string, payload?: object): AuditEvent;
+    notify(payload: AuditEvent): Promise<_sinequa_atomic.AuditEvents>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuditService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AuditService>;
+}
+
+type Notification = {
+    type: 'success' | 'error' | 'info' | 'warning';
+    title: string;
+    description?: string;
+    error?: any;
+};
+declare class NotificationsService {
+    readonly notifications: Subject<Notification>;
+    notify(notification: Notification): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationsService>;
+}
+
+/**
+ * This service exposes the only reference to the markdown renderer used in the agent.
+ * Built with injected plugins, it can be extended to support custom markdown syntax.
+ *
+ * @see {@link AGENT_RENDERER_PLUGINS} token
+ */
+declare class RendererService {
+    private readonly plugins;
+    private readonly shikiHighlighterService;
+    readonly renderer: MarkdownIt;
+    constructor();
+    private createRenderer;
+    private useShiki;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RendererService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RendererService>;
+}
+
+declare class ThemeService {
+    readonly mode: _angular_core.WritableSignal<"light" | "dark">;
+    constructor();
+    set(mode: 'light' | 'dark'): void;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+declare function themeInitializerFn(): void;
+
+declare class ShikiHighlighterService {
+    private readonly config;
+    private readonly themeService;
+    private readonly isDark;
+    private highlighterPromise;
+    private init;
+    applyToMarkdownIt(md: MarkdownIt): Promise<void>;
+    highlight(code: string, lang: string): Promise<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShikiHighlighterService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShikiHighlighterService>;
+}
+
+/**
+ * Manages the PKCE OAuth2 authorization flow for MCP clients.
+ *
+ * Handles: code verifier/challenge generation, opening the auth tab,
+ * listening for the postMessage callback from the OAuth callback route,
+ * and resolving the authorization code back to the caller.
+ */
+declare class McpOAuthService {
+    /** The MCP client currently awaiting OAuth authorization, or null when idle. */
+    readonly pendingClient: _angular_core.WritableSignal<McpClient | null>;
+    private currentCodeVerifier;
+    private pendingResolve;
+    private pendingReject;
+    private readonly messageListener;
+    /**
+     * Starts the PKCE OAuth2 flow for the given MCP client.
+     *
+     * Navigates the provided popup (or opens a new one) to the authorization URL with PKCE
+     * parameters appended, then waits for the callback page to post the authorization code
+     * back via postMessage.
+     *
+     * The `popup` parameter should be opened **synchronously** by the caller (before any
+     * `await`) to avoid browser popup blockers. Passing it here prevents a second `window.open`
+     * call after an async boundary.
+     *
+     * @param client - The MCP client to authorize. Must have `authorizationUrl` set.
+     * @param popup - A blank popup window already opened by the caller, or `undefined` to
+     *                let this method open one (only safe when called synchronously from a user gesture).
+     *
+     * @returns A promise that resolves with the authorization code and PKCE code verifier,
+     *          or rejects if the flow is cancelled or the popup could not be opened.
+     */
+    startOAuthFlow(client: McpClient, popup?: Window): Promise<{
+        code: string;
+        codeVerifier: string;
+    }>;
+    /**
+     * Cancels the in-progress OAuth flow, if any.
+     * Clears pending state and removes the message listener.
+     */
+    cancelOAuth(): void;
+    private handleOAuthMessage;
+    private cleanup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<McpOAuthService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<McpOAuthService>;
+}
+
+/**
+ * Generic modal shell with a side navigation menu.
+ *
+ * Provides a responsive two-layout shell:
+ *   - Mobile (below md): close button + projected body content
+ *   - Desktop (md+): fixed-width sidebar for navigation + scrollable content inset
+ *
+ * The caller fills three named content slots:
+ *   - [mobile-body]      Full mobile body, e.g. a <tabs> component with nav + section content
+ *   - [desktop-nav]      Sidebar navigation items, e.g. <sidebar-menu-item> elements
+ *   - [desktop-content]  Content shown in the inset next to the sidebar
+ *
+ * The caller is responsible for managing active-section state and conditional
+ * rendering of section content. Sidebar CSS variable theming (--sidebar-*, etc.)
+ * can be overridden by setting them on the caller's :host styles block — they
+ * cascade through the DOM to the sidebar-provider inside this component.
+ *
+ * Usage:
+ *   <MenuModal (closed)="onClose()">
+ *     <tabs mobile-body>...</tabs>
+ *     <sidebar-menu-item desktop-nav>...</sidebar-menu-item>
+ *     <div desktop-content>...</div>
+ *   </MenuModal>
+ */
+declare class MenuModalComponent {
+    /** Emitted when the user clicks the close button in either mobile or desktop view. */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuModalComponent, "MenuModal,menu-modal", never, {}, { "closed": "closed"; }, never, ["[mobile-body]", "[desktop-nav]", "[desktop-content]"], true, never>;
+}
+
+declare class SettingsComponent {
+    private readonly agentsStore;
+    private readonly router;
+    readonly toggled: _angular_core.WritableSignal<boolean>;
+    readonly debug: _angular_core.ModelSignal<boolean>;
+    private readonly appearanceDialog;
+    logout(): void;
+    openAppearance(): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SettingsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SettingsComponent, "Settings,settings", never, { "debug": { "alias": "debug"; "required": false; "isSignal": true; }; }, { "debug": "debugChange"; }, never, never, true, never>;
+}
+
+declare class SettingsModalComponent {
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly activeSection: _angular_core.WritableSignal<"theme">;
+    readonly theme: _angular_core.WritableSignal<"system" | "light" | "dark">;
+    readonly widerView: _angular_core.WritableSignal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SettingsModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SettingsModalComponent, "SettingsModal,settings-modal", never, {}, { "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class ChartPlotComponent {
+    readonly chartPlotRef: _angular_core.Signal<ElementRef<HTMLCanvasElement>>;
+    private readonly destroyRef;
+    private chart?;
+    constructor();
+    private parseChartJsConfig;
+    private getChartJsConfig;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartPlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartPlotComponent, "chart-plot", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class CodeBlockComponent {
+    private readonly el;
+    readonly language: _angular_core.InputSignal<string>;
+    onCopySuccess(text: string): void;
+    private dispatchEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CodeBlockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CodeBlockComponent, "code-block", never, { "language": { "alias": "language"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class InlineReferenceComponent {
+    private readonly destroyRef;
+    private readonly selectionStore;
+    private readonly previewService;
+    protected readonly agentsStore: {
+        ready: _angular_core.Signal<boolean>;
+        savedChatReady: _angular_core.Signal<boolean>;
+        debugMessages: _angular_core.Signal<boolean>;
+        referenceCache: _angular_core.Signal<Record<string, Reference>>;
+        agentDetails: _angular_core.Signal<_sinequa_agent.AgentDetails | undefined>;
+        agentDetailsLoading: _angular_core.Signal<boolean>;
+        toolChoice: _angular_core.Signal<_sinequa_agent.ToolChoice | undefined>;
+        setReady: (ready: boolean) => void;
+        setSavedChatReady: (ready: boolean) => void;
+        getAgentInstanceConfiguration: (instanceId: string) => z.infer<typeof _sinequa_agent.AgentConfigSchema> | undefined;
+        setDebugMessages: (debug: boolean) => void;
+        setReferences: (references: Record<string, Reference>) => void;
+        addReference: (reference: Reference) => void;
+        addReferences: (references: Record<string, Reference>) => void;
+        getReferenceMetas: (id: string) => Reference["metas"] | undefined;
+        getAgentDetails: (name: string) => void;
+        updateAgentDetails: (name: string) => void;
+        reloadAgentDetails: () => void;
+        updateToolChoice: (toolChoice: _sinequa_agent.ToolChoice) => void;
+    } & _ngrx_signals.WritableStateSource<{
+        ready: boolean;
+        savedChatReady: boolean;
+        debugMessages: boolean;
+        referenceCache: Record<string, Reference>;
+        agentDetails: _sinequa_agent.AgentDetails | undefined;
+        agentDetailsLoading: boolean;
+        toolChoice: _sinequa_agent.ToolChoice | undefined;
+    }>;
+    readonly rawData: _angular_core.InputSignalWithTransform<string, string>;
+    readonly references: _angular_core.Signal<InlineReference[]>;
+    readonly highlights: _angular_core.Signal<{
+        offset: number;
+        length: number;
+    }[]>;
+    readonly controller: AbortController;
+    private selectedIndex;
+    listen: (event: MessageEvent) => void;
+    constructor();
+    select(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InlineReferenceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InlineReferenceComponent, "inline-reference", never, { "rawData": { "alias": "data-references"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TableWrapperComponent {
+    private readonly el;
+    private readonly copyState;
+    protected readonly hasCopied: _angular_core.Signal<boolean>;
+    copyAsCSV(event: Event): Promise<void>;
+    downloadAsCSV(): void;
+    private extractCSV;
+    private dispatchEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableWrapperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableWrapperComponent, "table-wrapper", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare function markdownItCodeBlockPlugin(md: MarkdownIt): void;
+
+declare function markdownItInlineReferencePlugin(md: MarkdownIt): void;
+
+/**
+ * This plugin wraps the default link renderer to add `target="_blank"` and
+ * `rel="noopener noreferrer"` attributes to all links.
+ */
+declare function markdownItLinkPlugin(md: MarkdownIt): void;
+
+/**
+ * This plugin adds the `markdown-list` CSS class to root-level bullet and
+ * ordered lists rendered by markdown-it, enabling scoped styling without
+ * wrapping the list in an extra element.
+ */
+declare function markdownItListPlugin(md: MarkdownIt): void;
+
+/**
+ * This plugin wraps the default table renderer into a custom `<table-wrapper>`
+ * tag.
+ */
+declare function markdownItTableWrapperPlugin(md: MarkdownIt): void;
+
+/**
+ * Markdown-it plugin to replace ```chartjs fenced blocks
+ * with <chart-plot> custom elements.
+ */
+declare function markdownItChartJsPlugin(md: MarkdownIt): void;
+
+declare class SmartRendererComponent {
+    private readonly rendererService;
+    readonly message: _angular_core.InputSignal<string | null | undefined>;
+    readonly context: _angular_core.InputSignal<any>;
+    readonly done: _angular_core.InputSignal<boolean>;
+    readonly safe: _angular_core.WritableSignal<string>;
+    readonly processing: _angular_core.WritableSignal<string>;
+    private renderer;
+    private lastSliceIndex;
+    private localSliceIndex;
+    constructor();
+    messageUpdated(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmartRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmartRendererComponent, "SmartRenderer, smartrenderer, smart-renderer", never, { "message": { "alias": "message"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; "done": { "alias": "done"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Copies the given text to the clipboard to the navigator clipboard.
+ *
+ * @param text - The text to copy to clipboard.
+ *
+ * @returns A promise that resolves when the text has been copied.
+ */
+declare function copyToClipboard(text: string): Promise<void>;
+/**
+ * Creates an isolated copy state with a `hasCopied` readonly signal and a `copy()` method.
+ * The `hasCopied` signal is automatically reset to `false` after `resetDelay` ms.
+ *
+ * @param resetDelay - How long (in ms) to keep `hasCopied` as `true`. Defaults to 2000.
+ */
+declare function createCopyState(resetDelay?: number): {
+    hasCopied: _angular_core.Signal<boolean>;
+    copy: (text: string) => Promise<void>;
+};
+
+declare function checkUUID(uuid: string): boolean;
+
+/**
+ * Slices the history from the given messageId (inclusive).
+ *
+ * @param history - The history to slice.
+ * @param messageId - The messageId to slice from (inclusive).
+ *
+ * @returns The sliced history.
+ */
+declare function sliceHistoryFromMessageId(history: Message[], messageId: string | undefined): Message[];
+
+/**
+ * Transforms the message content into a string format suitable for rendering.
+ * Special message contents, like images or videos, are currently ignored.
+ * @param messageContent - The list of {@link MessageContent} to transform into a string
+ * @returns The transformed message contents as a string
+ */
+declare function flattenMessageContent(messageContent: MessageContent[] | undefined): string;
+/**
+ * Identifies the type of a message based on its role and content.
+ * @param message - The message to identify.
+ * @returns The identified message type as a string.
+ */
+declare function identifyMessage(message?: Message): MessageIdentity | undefined;
+/**
+ * Determines if a message could be a streamed message.
+ * @param message - The message to check.
+ * @returns True if the message is a potential streamed message, false otherwise.
+ */
+declare function isAStreamMessage(message: Message | undefined): boolean;
+
+declare function debouncedSignal<T>(sourceSignal: Signal<T>, debounceTimeInMs?: number): Signal<T>;
+
+/**
+ * Returns the URL without duplicate slashes (be cautious with the "http(s)://" part)
+ * @param url - The URL to clean
+ * @returns The cleaned URL
+ */
+declare function cleanURL(url: string): string;
+/**
+ * Concatenates multiple parts of a URL and cleans it (be cautious with the "http(s)://" part)
+ * @param url - The parts of the URL to concatenate
+ * @returns The concatenated and cleaned URL
+ */
+declare function concatURL(...url: string[]): string;
+declare function toURLSearchParams(object: object): URLSearchParams;
+
+declare class ShikiCodeComponent implements AfterViewInit {
+    private shiki;
+    private readonly el;
+    lang: _angular_core.InputSignal<string>;
+    enableCopy: _angular_core.InputSignal<boolean>;
+    classes: _angular_core.InputSignal<string>;
+    copySuccess: _angular_core.OutputEmitterRef<string>;
+    copyError: _angular_core.OutputEmitterRef<unknown>;
+    private readonly shikiContainer;
+    private readonly copyState;
+    protected readonly hasCopied: _angular_core.Signal<boolean>;
+    private rawCode;
+    ngAfterViewInit(): Promise<void>;
+    copy(event: Event): Promise<void>;
+    private hasPreRenderedShiki;
+    private extractRawCode;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShikiCodeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShikiCodeComponent, "shiki-code,ShikiCode,shikicode", never, { "lang": { "alias": "lang"; "required": true; "isSignal": true; }; "enableCopy": { "alias": "enableCopy"; "required": false; "isSignal": true; }; "classes": { "alias": "classes"; "required": false; "isSignal": true; }; }, { "copySuccess": "copySuccess"; "copyError": "copyError"; }, never, ["*"], true, never>;
+}
+
+export { ADMIN_EVENT_NAME, AGENT_ACTION_EVENT_NAME, AGENT_DEFAULT_NAME, AGENT_ERROR_EVENT_NAME, AGENT_EVENT_NAME, AGENT_INSTANCE_ID, AGENT_NEW_CHAT_EVENT_NAME, AGENT_RENDERER_PLUGINS, AGENT_TOOL_CARD_PLUGINS, ASignalRService, AdditionalToolPropertiesSchema, AdminDirective, Agent, AgentConfigSchema, AgentConfigurationService, AgentGenerationDirective, AgentInjector, AgentService, AgentsStore, AuditService, AuditSettingsSchema, AvailableInternalToolsComponent, AvailableMcpServersComponent, ButtonComponent, CastToDebugKVPipe, CastToDebugListPipe, ChartPlotComponent, ChatInput, ChatInputMode, CodeBlockComponent, ConnectionSettingsSchema, CopyToClipboardDirective, CopyableFieldComponent, DebugService, DocumentCardComponent, ErrorDirective, ExpandedSearchResultsComponent, FeedbackDirective, GlobalSettingsSchema, HyperlinkComponent, INSPECT_XSTATE, InfoPanelComponent, InlineReferenceComponent, LoggerService, Machine, McpConnectDialogComponent, McpOAuthService, McpServerItemComponent, MenuModalComponent, MessageAgentComponent, MessageAgentToolbar, MessageBaseComponent, MessageBuilder, MessageDebugComponent, MessageDebugDetailsComponent, MessageDebugEntryComponent, MessageDebugKVComponent, MessageDebugListComponent, MessageFunctionComponent, MessageList, MessageService, MessageUserComponent, MessageUserToolbar, NotificationsService, OAuthCallbackComponent, ReadDocumentFunctionComponent, RendererService, SHIKI_HIGHLIGHTER_CONFIG, SIGNALR_RETRY_DELAYS, SIGNALR_RETRY_DELAYS_DEFAULT, SafeHtmlPipe, SavedChatActions, SavedChatComponent, SavedChatEvent, SavedChatSettingsSchema, SavedChatsDialogComponent, SavedChatsService, SearchExpansionService, SearchFunctionComponent, SearchResultsTabsComponent, SettingsComponent, SettingsModalComponent, ShikiCodeComponent, ShikiHighlighterService, SignalRLogLevelSchema, SignalRService, SignalRTransportSchema, SignalRWebService, SmartRendererComponent, TableWrapperComponent, ThemeService, ToolsSelectionPanelComponent, buttonVariants, checkUUID, cleanURL, concatURL, copyToClipboard, createActionEvent, createAdminEvent, createAgentErrorEvent, createAgentEvent, createAgentNewChatEvent, createCopyState, debouncedSignal, flattenMessageContent, hyperlinkVariants, identifyMessage, isAStreamMessage, isAgentActionEvent, isInputActionEvent, isUserActionEvent, markdownItChartJsPlugin, markdownItCodeBlockPlugin, markdownItInlineReferencePlugin, markdownItLinkPlugin, markdownItListPlugin, markdownItTableWrapperPlugin, provideDefaultRendererPlugins, provideDefaultShikiHighlighterConfig, provideDefaultToolCardPlugins, provideRendererPlugins, provideSavedChatsService, provideShikiHighlighterConfig, provideToolCardPlugins, sliceHistoryFromMessageId, themeInitializerFn, toURLSearchParams, withAgentDetailsFeatures, withAgentsFeatures, withDebugFeatures };
+export type { ActionEvent, AdditionalProperties, AdditionalToolProperties, AdminEvent, AdminEventId, AdminEventPayload, AgentAuditType, AgentConfig, AgentDetails, AgentDetailsState, AgentErrorEvent, AgentErrorId, AgentEvent, AgentEventId, AgentMachineContext, AgentMachineEvents, AgentMachineInput, AgentNewChatEvent, AgentsState, ApplicationContext, AuditSettings, BasePayload, ButtonVariants, ConnectionOptions, ConnectionSettings, ContextDocument, ContextDocumentChunk, ContextDocumentMeta, ContextProperties, DebugDisplayFrame, DebugDisplayItem, DebugDisplayItemData, DebugDisplayItemKV, DebugDisplayItemList, DebugMessage, DebugMessageGroup, DebugMessageListPayload, DebugMessageProperties, DebugState, FrameEvent, FrameEventName, FrameEventType, FunctionCall, GlobalSettings, HistoryContent, HistoryContentBase, HistoryContentImage, HistoryContentText, HistoryContentVideo, HistoryFrame, HyperlinkVariants, InlineReference, InputAction, InputActionEvent, InstanceState, InternalTool, MarkdownItPlugin, McpAuthorizationStatus, McpClient, McpTool, Message, MessageAgentAction, MessageAgentActionEvent, MessageComponentType, MessageContent, MessageContentFunctionApprovalRequest, MessageContentFunctionApprovalResponse, MessageContentFunctionCall, MessageContentFunctionResult, MessageContentImage, MessageContentText, MessageContentVideo, MessageFrame, MessageIdentity, MessageRole, MessageType, MessageUserAction, MessageUserActionEvent, Notification, OAuthRequiredFrame, RendererPlugins, SavedChat, SavedChatAddPayload, SavedChatDeletePayload, SavedChatExistsPayload, SavedChatGetPayload, SavedChatListPayload, SavedChatSettings, SavedChatUpdatePayload, SearchContext, ShikiConfig, ShikiThemeMode, SignalRConnectionOperationConfig, SignalREvent, SignalREventBase, SignalREventConnected, SignalREventDisconnected, SignalREventReconnecting, SignalRLogLevel, SignalRTransport, ToolCardPlugins, ToolChoice, UserFeedback, UserFeedbackNegative, UserFeedbackPositive, functionCallFrame, functionResultFrame };