@acorex-platform/extension-ai-conversation-client 0.0.21

package/fesm2022/acorex-platform-extension-ai-conversation-client-acorex-platform-extension-ai-conversation-client-ZUV9J76R.mjs

@@ -0,0 +1,1913 @@
+import { AXP_SEARCH_PROVIDER, AXP_SEARCH_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/common';
+import * as i1$1 from '@acorex-platform/framework-client/core';
+import { AXPComponentSlotModule, provideAppStartUpTask, AXP_APP_STARTUP_PRIORITY } from '@acorex-platform/framework-client/core';
+import { AXPRuntimeTransportService, AXPCommandService, provideCommandSetups } from '@acorex-platform/framework-client/runtime';
+import { AXM_AI_MANAGEMENT_MODULE_NAME, AXM_AI_MANAGEMENT_ASSIST_ENTITY_NAME, AXMConversationEntityStoreService, axmChatAiTargetDisplayName, axmChatAiTargetDisplayDescription, axmChatAiTargetAvatarUrl, axmFilterChatAiTargets, axmChatAiPeerParticipantId, axmBuildAiChatConversationMetadata, CONVERSATION_START_ASSIST_CHAT_COMMAND, axmChatAiTargetShortcutDescriptionKey, AXM_ASSIST_DEFAULT_RESOLVER_PORT, axmAssistStarterPromptChipItems, AXMAssistSuggestionChipsComponent, AXM_CHAT_EMPTY_STATE_COMPONENT, AXM_MINI_CHAT_INBOX_CONVERSATION_FILTER, axmConversationHasAiChat, AXMConversationFocusService, axmIsAssistRetryableStatus, axmReadAssistResponseStatus, axmReadReplyToUserMessageId, axmMessageEntityToMessage, axmAssistPersistedMessageLooksComplete, axmShouldPreferPersistedAssistOverLiveCache, axmRoomWithAssistPeerDisplayName, axmSyncAssistPeerDisplayName, axmRoomEntityToConversation, axmIsAssistTerminalStatus, CONVERSATION_SYNC_READ_STATE_COMMAND, axmAssistHasFinalizeMetadata, AXM_CHAT_SIDEBAR_ACTION_PROVIDER, AXMMiniChatHeaderSlotComponent, AXM_CONVERSATION_ASSIST_RESPONSE_PORT, AXM_CHAT_ASSIST_CATALOG_PORT, AXM_CONVERSATION_ASSIST_BACKGROUND_OPERATION_HANDLERS, CONVERSATION_SEND_ASSIST_CHAT_MESSAGE_COMMAND } from '@acorex-platform/module-conversation-client';
+import * as i0 from '@angular/core';
+import { inject, Injectable, output, input, signal, computed, viewChild, effect, ChangeDetectionStrategy, Component, Injector, NgModule } from '@angular/core';
+import { AXPSystemActionType, runtimeCommandPayloadData } from '@acorex-platform/framework-shared/core';
+import { sortBy } from 'lodash-es';
+import { AXConversationService } from '@acorex/components/conversation';
+import { AXToastService } from '@acorex/components/toast';
+import * as i6 from '@acorex/core/translation';
+import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
+import { AXPSessionService } from '@acorex-platform/framework-client/auth';
+import { AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
+import { Router } from '@angular/router';
+import { AXPLayoutThemeService } from '@acorex-platform/framework-client/themes/shared';
+import * as i2 from '@acorex/components/button';
+import { AXButtonModule, AXButtonComponent } from '@acorex/components/button';
+import * as i4 from '@acorex/components/decorators';
+import { AXDecoratorModule, AXDecoratorGenericComponent } from '@acorex/components/decorators';
+import * as i3 from '@acorex/components/dropdown';
+import { AXDropdownModule } from '@acorex/components/dropdown';
+import { AXTextBoxModule } from '@acorex/components/text-box';
+import * as i5 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i1 from '@angular/forms';
+import { FormsModule } from '@angular/forms';
+import { AXPAiManagerService } from '@acorex-platform/module-ai-management-client';
+import { AXMAiManagementTransportKeys, AIMANAGEMENT_STRUCTURED_TEXT_COMPLETION_COMMAND_KEY, axpAiChatTextMessage } from '@acorex-platform/module-ai-management-client/contracts';
+import { axmCompareMessagesChronologically, axmExtractAssistIdFromMetadata, AXM_ASSIST_CONVERSATION_TITLE_SYSTEM_PROMPT, axmSanitizeAiGeneratedConversationTitle, extractMessageTextFromPayload, axmEnsureAssistMessageSortsAfterReplyTarget } from '@acorex-platform/module-conversation-client/contracts';
+import { AXPopupService } from '@acorex/components/popup';
+import { AXPAvatarComponent } from '@acorex-platform/framework-client/layout/components';
+import { AXDataSource, AXComponentCloseEvent, AXClosableComponent } from '@acorex/cdk/common';
+import { AXListComponent } from '@acorex/components/list';
+import { AXBasePageComponent } from '@acorex/components/page';
+import { AXSearchBoxComponent } from '@acorex/components/search-box';
+import { AXSkeletonComponent } from '@acorex/components/skeleton';
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Service ----
+/**
+ * In-memory assist catalog for chat pickers and welcome UI (AI extension).
+ * Loads assist rows once via Query and dedupes GetById for starter prompts / metadata.
+ */
+class AXMChatAssistCatalogService {
+    constructor() {
+        //#region ---- Services & Dependencies -----
+        this.entityService = inject(AXPEntityService);
+        this.assistData = this.entityService
+            .withEntity(AXM_AI_MANAGEMENT_MODULE_NAME, AXM_AI_MANAGEMENT_ASSIST_ENTITY_NAME)
+            .data();
+        //#endregion
+        //#region ---- State Signals -----
+        this.catalogTargets = null;
+        this.fullRowsById = new Map();
+        this.loadPromise = null;
+        this.byKeyChains = new Map();
+    }
+    //#endregion
+    //#region ---- Catalog ----
+    async loadCatalogTargets(force = false) {
+        // Never treat an empty first paint as a permanent cache — early opens can race entity readiness.
+        if (!force && this.catalogTargets != null && this.catalogTargets.length > 0) {
+            return this.catalogTargets;
+        }
+        if (!force && this.loadPromise) {
+            return this.loadPromise;
+        }
+        this.loadPromise = this.fetchCatalogTargets();
+        try {
+            this.catalogTargets = await this.loadPromise;
+            return this.catalogTargets;
+        }
+        finally {
+            this.loadPromise = null;
+        }
+    }
+    async fetchCatalogTargets() {
+        const queryResult = await this.assistData.query({
+            skip: 0,
+            take: 500,
+        });
+        const items = (queryResult?.items ?? []);
+        const targets = [];
+        for (const item of items) {
+            const id = String(item.id ?? '').trim();
+            if (!id) {
+                continue;
+            }
+            this.fullRowsById.set(id, item);
+            targets.push(this.toTargetRow(item));
+        }
+        return targets.sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: 'base' }));
+    }
+    toTargetRow(item) {
+        const id = String(item.id ?? '').trim();
+        return {
+            id,
+            name: String(item.name ?? ''),
+            title: (item.title ?? item.name ?? id),
+            description: item.description,
+            professionImageUrl: typeof item.professionImageUrl === 'string' ? item.professionImageUrl : undefined,
+        };
+    }
+    //#endregion
+    //#region ---- Assist reads ----
+    getCachedAssist(assistId) {
+        const scoped = assistId?.trim();
+        if (!scoped) {
+            return null;
+        }
+        return this.fullRowsById.get(scoped) ?? null;
+    }
+    async getAssist(assistId) {
+        const scoped = assistId?.trim();
+        if (!scoped) {
+            return null;
+        }
+        const cached = this.fullRowsById.get(scoped);
+        if (cached) {
+            return cached;
+        }
+        const inflight = this.byKeyChains.get(scoped);
+        if (inflight) {
+            return inflight;
+        }
+        const task = this.assistData.byKey(scoped).then((row) => {
+            if (row) {
+                this.fullRowsById.set(scoped, row);
+            }
+            return row ?? null;
+        });
+        this.byKeyChains.set(scoped, task);
+        try {
+            return await task;
+        }
+        finally {
+            if (this.byKeyChains.get(scoped) === task) {
+                this.byKeyChains.delete(scoped);
+            }
+        }
+    }
+    primeAssist(row) {
+        const id = row.id?.trim();
+        if (!id) {
+            return;
+        }
+        this.fullRowsById.set(id, row);
+    }
+    toSnapshot(row) {
+        return {
+            initialMessages: row.initialMessages,
+            starterPrompts: row.starterPrompts,
+            modelId: row.modelId,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMChatAssistCatalogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMChatAssistCatalogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMChatAssistCatalogService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXMChatAssistLauncherService {
+    constructor() {
+        this.conversationService = inject(AXConversationService);
+        this.assistCatalog = inject(AXMChatAssistCatalogService);
+        this.entityStore = inject(AXMConversationEntityStoreService);
+        this.translationService = inject(AXTranslationService);
+        this.sessionService = inject(AXPSessionService);
+        this.router = inject(Router);
+        this.toastService = inject(AXToastService);
+    }
+    async loadTargets(force = false) {
+        return this.assistCatalog.loadCatalogTargets(force);
+    }
+    displayName(row) {
+        return axmChatAiTargetDisplayName(this.#resolveMl.bind(this), row);
+    }
+    displayDescription(row) {
+        return axmChatAiTargetDisplayDescription(this.#resolveMl.bind(this), row);
+    }
+    targetAvatarUrl(row) {
+        return axmChatAiTargetAvatarUrl(row);
+    }
+    filterTargets(rows, query) {
+        return axmFilterChatAiTargets(this.#resolveMl.bind(this), rows, query);
+    }
+    async startAssistChat(options) {
+        const targetId = (options.targetId ?? options.assistId)?.trim();
+        if (!targetId) {
+            return null;
+        }
+        const row = options.targetRow ?? (await this.loadTargets()).find((r) => r.id === targetId);
+        if (!row) {
+            const message = await this.translationService.translateAsync('@conversation:chat.assist-dialog.errors.start-chat');
+            this.toastService.danger(message);
+            return null;
+        }
+        return this.startAssistChatFromRow(row, options.navigate !== false);
+    }
+    async startAssistChatFromRow(row, navigate = true) {
+        try {
+            const conversation = await this.#createTargetConversation(row);
+            await this.conversationService.selectConversation(conversation.id);
+            if (navigate) {
+                await this.navigateToConversation(conversation.id);
+            }
+            return { conversation };
+        }
+        catch (error) {
+            console.error('Failed to start AI chat:', error);
+            const message = await this.translationService.translateAsync('@conversation:chat.assist-dialog.errors.start-chat');
+            this.toastService.danger(message);
+            return null;
+        }
+    }
+    /** Navigate after the picker dialog has emitted close — avoids ObjectUnsubscribedError on popup teardown. */
+    async navigateToConversation(conversationId) {
+        const scoped = conversationId.trim();
+        if (!scoped) {
+            return;
+        }
+        await this.router.navigate([this.#applicationRouteSegment(), 'chat', scoped]);
+    }
+    async #createTargetConversation(row) {
+        await this.assistCatalog.loadCatalogTargets();
+        const participantId = axmChatAiPeerParticipantId(row.id);
+        const title = this.displayName(row);
+        const avatar = this.targetAvatarUrl(row);
+        const assistRow = this.assistCatalog.getCachedAssist(row.id);
+        const assistSnapshot = assistRow ? this.assistCatalog.toSnapshot(assistRow) : undefined;
+        const conversation = await this.conversationService.createConversation([participantId], 'bot', {
+            title,
+            ...(avatar ? { avatar } : {}),
+            icon: 'fa-solid fa-robot',
+            metadata: axmBuildAiChatConversationMetadata(row, assistSnapshot),
+        });
+        this.entityStore.cacheConversation(conversation);
+        this.entityStore.cacheEmptyMessageList(conversation.id);
+        return conversation;
+    }
+    #resolveMl(value) {
+        return this.translationService.resolve(value);
+    }
+    #applicationRouteSegment() {
+        return this.sessionService.application?.name ?? 'platform';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMChatAssistLauncherService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMChatAssistLauncherService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMChatAssistLauncherService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/** Search group key used by Conversation AI extension. */
+const AXM_CONVERSATION_ASSIST_SEARCH_GROUP = 'conversation-assist';
+class AXMConversationAssistSearchProvider {
+    constructor() {
+        this.launcher = inject(AXMChatAssistLauncherService);
+    }
+    async search(text) {
+        let rows;
+        try {
+            rows = await this.launcher.loadTargets();
+        }
+        catch (error) {
+            console.error('Failed to load AI chat targets for shortcut search:', error);
+            return [];
+        }
+        const filtered = this.launcher.filterTargets(rows, text);
+        const sorted = sortBy(filtered, (row) => this.launcher.displayName(row).toLowerCase());
+        return sorted.map((row) => ({
+            id: row.id,
+            group: AXM_CONVERSATION_ASSIST_SEARCH_GROUP,
+            title: row.title,
+            description: row.description ?? axmChatAiTargetShortcutDescriptionKey(),
+            icon: 'fa-solid fa-robot',
+            data: { id: row.id, name: row.name },
+            command: {
+                name: CONVERSATION_START_ASSIST_CHAT_COMMAND,
+                options: {
+                    targetId: row.id,
+                },
+            },
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMConversationAssistSearchProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMConversationAssistSearchProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMConversationAssistSearchProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMConversationAssistSearchDefinitionProvider {
+    async provide(context) {
+        context.addDefinition(AXM_CONVERSATION_ASSIST_SEARCH_GROUP, '@conversation:search.assist.group-title', AXM_CONVERSATION_ASSIST_SEARCH_GROUP, 'fa-solid fa-robot', 4, {
+            format: {
+                id: '{{id}}',
+            },
+            actions: [
+                {
+                    name: 'start-assist-chat',
+                    type: AXPSystemActionType.View,
+                    priority: 'primary',
+                },
+            ],
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMConversationAssistSearchDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMConversationAssistSearchDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMConversationAssistSearchDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMChatEmptyAssistComposerComponent {
+    constructor() {
+        this.conversationService = inject(AXConversationService);
+        this.toastService = inject(AXToastService);
+        this.translationService = inject(AXTranslationService);
+        this.assistCatalog = inject(AXMChatAssistCatalogService);
+        this.layoutTheme = inject(AXPLayoutThemeService);
+        this.defaultAssistResolver = inject(AXM_ASSIST_DEFAULT_RESOLVER_PORT, { optional: true });
+        this.conversationCreated = output();
+        this.initialAssistId = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "initialAssistId" }] : /* istanbul ignore next */ []));
+        this.entityId = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "entityId" }] : /* istanbul ignore next */ []));
+        this.entityType = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "entityType" }] : /* istanbul ignore next */ []));
+        this.sendStarterPromptsInPlace = input(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "sendStarterPromptsInPlace" }] : /* istanbul ignore next */ []));
+        this.compact = input(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "compact" }] : /* istanbul ignore next */ []));
+        this.rows = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "rows" }] : /* istanbul ignore next */ []));
+        this.loading = signal(true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
+        this.selectedAssistId = signal(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedAssistId" }] : /* istanbul ignore next */ []));
+        this.starterPromptItems = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "starterPromptItems" }] : /* istanbul ignore next */ []));
+        this.draftText = signal('', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "draftText" }] : /* istanbul ignore next */ []));
+        this.sending = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "sending" }] : /* istanbul ignore next */ []));
+        this.isBusy = computed(() => this.sending() || this.loading(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isBusy" }] : /* istanbul ignore next */ []));
+        this.draftInput = viewChild('draftInput', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "draftInput" }] : /* istanbul ignore next */ []));
+        this.selectedAssistLabel = computed(() => {
+            const selected = this.rows().find((row) => row.id === this.selectedAssistId());
+            return selected?.title;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedAssistLabel" }] : /* istanbul ignore next */ []));
+        this.maxDraftHeightPx = computed(() => (this.compact() ? 128 : 224), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "maxDraftHeightPx" }] : /* istanbul ignore next */ []));
+        this.assistsLoadPromise = null;
+        this.starterPromptsLoadGeneration = 0;
+        void this.ensureAssistsLoaded();
+        effect(() => {
+            void this.loadStarterPromptsForAssist(this.selectedAssistId());
+        });
+        effect(() => {
+            this.draftText();
+            queueMicrotask(() => this.resizeDraftInput());
+        });
+    }
+    onAssistIdChange(value) {
+        this.selectedAssistId.set(value?.trim() || undefined);
+    }
+    canSend() {
+        return Boolean(this.selectedAssistId() && this.draftText().trim().length > 0 && !this.sending() && !this.loading());
+    }
+    resizeDraftInput() {
+        const textarea = this.draftInput()?.nativeElement;
+        if (!textarea)
+            return;
+        textarea.style.height = '0px';
+        textarea.style.height = `${Math.min(textarea.scrollHeight, this.maxDraftHeightPx())}px`;
+    }
+    onDraftKeydown(event) {
+        if (event.key !== 'Enter' || event.shiftKey || event.isComposing)
+            return;
+        event.preventDefault();
+        if (this.canSend())
+            void this.send();
+    }
+    async send() {
+        const assistId = this.selectedAssistId();
+        const text = this.draftText().trim();
+        if (!assistId || !text || this.sending())
+            return;
+        const row = this.rows().find((r) => r.id === assistId);
+        if (!row)
+            return;
+        this.sending.set(true);
+        this.layoutTheme.setOverlayLoading(true);
+        try {
+            const participantId = axmChatAiPeerParticipantId(row.id);
+            const avatar = row.professionImageUrl?.trim() || undefined;
+            const entityId = this.entityId()?.trim();
+            const entityType = this.entityType()?.trim();
+            const assistRow = this.assistCatalog.getCachedAssist(row.id) ?? (await this.assistCatalog.getAssist(row.id));
+            const assistSnapshot = assistRow ? this.assistCatalog.toSnapshot(assistRow) : undefined;
+            const conversation = await this.conversationService.createConversation([participantId], 'bot', {
+                title: this.translationService.resolve(row.title) ?? row.name,
+                ...(avatar ? { avatar } : {}),
+                icon: 'fa-solid fa-robot',
+                metadata: {
+                    ...axmBuildAiChatConversationMetadata(row, assistSnapshot),
+                    ...(entityId && entityType ? { entityId, entityType } : {}),
+                },
+            });
+            await this.conversationService.selectConversation(conversation.id);
+            const payload = { type: 'text', text };
+            await this.conversationService.sendMessage({ conversationId: conversation.id, type: 'text', payload });
+            this.draftText.set('');
+            this.conversationCreated.emit(conversation.id);
+        }
+        catch {
+            const message = await this.translationService.translateAsync('@conversation:chat.empty-assist.errors.send');
+            this.toastService.danger(message);
+        }
+        finally {
+            this.sending.set(false);
+            this.layoutTheme.setOverlayLoading(false);
+        }
+    }
+    async ensureAssistsLoaded() {
+        if (!this.assistsLoadPromise)
+            this.assistsLoadPromise = this.loadAssistsFromApi();
+        await this.assistsLoadPromise;
+    }
+    async loadAssistsFromApi() {
+        this.loading.set(true);
+        try {
+            let rows = await this.assistCatalog.loadCatalogTargets();
+            if (!rows.length) {
+                rows = await this.assistCatalog.loadCatalogTargets(true);
+            }
+            this.rows.set(rows);
+            this.selectedAssistId.set(await this.resolveInitialAssistId(rows));
+        }
+        catch (error) {
+            console.error('Failed to load AI chat targets (empty composer):', error);
+            const message = await this.translationService.translateAsync('@conversation:chat.empty-assist.errors.load-assists');
+            this.toastService.danger(message);
+            this.rows.set([]);
+            this.selectedAssistId.set(undefined);
+        }
+        finally {
+            this.loading.set(false);
+        }
+    }
+    async resolveInitialAssistId(rows) {
+        if (!rows.length)
+            return undefined;
+        const requestedId = this.initialAssistId()?.trim();
+        if (requestedId && rows.some((row) => row.id === requestedId))
+            return requestedId;
+        const defaultAssistId = await this.resolveDefaultAssistId();
+        if (defaultAssistId && rows.some((row) => row.id === defaultAssistId))
+            return defaultAssistId;
+        return rows[0]?.id;
+    }
+    async resolveDefaultAssistId() {
+        if (!this.defaultAssistResolver)
+            return undefined;
+        try {
+            return await this.defaultAssistResolver.getDefaultAssistId();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async loadStarterPromptsForAssist(assistId) {
+        const generation = ++this.starterPromptsLoadGeneration;
+        const id = assistId?.trim();
+        if (!id) {
+            this.starterPromptItems.set([]);
+            return;
+        }
+        try {
+            const assist = await this.assistCatalog.getAssist(id);
+            if (!assist || generation !== this.starterPromptsLoadGeneration) {
+                if (generation === this.starterPromptsLoadGeneration && !assist) {
+                    this.starterPromptItems.set([]);
+                }
+                return;
+            }
+            const entityId = this.entityId()?.trim();
+            const entityType = this.entityType()?.trim();
+            const isEntityChat = Boolean(entityId && entityType);
+            const sendInPlace = this.sendStarterPromptsInPlace();
+            this.starterPromptItems.set(axmAssistStarterPromptChipItems(assist, {
+                assistId: id,
+                ...(isEntityChat ? { entityId, entityType } : {}),
+                ...(sendInPlace || isEntityChat ? { navigate: false } : {}),
+            }));
+        }
+        catch {
+            if (generation === this.starterPromptsLoadGeneration)
+                this.starterPromptItems.set([]);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMChatEmptyAssistComposerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXMChatEmptyAssistComposerComponent, isStandalone: true, selector: "axm-chat-empty-assist-composer", inputs: { initialAssistId: { classPropertyName: "initialAssistId", publicName: "initialAssistId", isSignal: true, isRequired: false, transformFunction: null }, entityId: { classPropertyName: "entityId", publicName: "entityId", isSignal: true, isRequired: false, transformFunction: null }, entityType: { classPropertyName: "entityType", publicName: "entityType", isSignal: true, isRequired: false, transformFunction: null }, sendStarterPromptsInPlace: { classPropertyName: "sendStarterPromptsInPlace", publicName: "sendStarterPromptsInPlace", isSignal: true, isRequired: false, transformFunction: null }, compact: { classPropertyName: "compact", publicName: "compact", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { conversationCreated: "conversationCreated" }, host: { properties: { "class.axm-chat-empty-assist-composer-host--compact": "compact()" }, classAttribute: "axm-chat-empty-assist-composer-host" }, viewQueries: [{ propertyName: "draftInput", first: true, predicate: ["draftInput"], descendants: true, isSignal: true }], ngImport: i0, template: `
+    <div class="axm-chat-empty-assist-composer">
+      <div class="axm-chat-empty-assist-composer__caption">
+        {{ '@conversation:chat.empty-assist.caption' | translate | async }}
+      </div>
+
+      <div class="axm-chat-empty-assist-composer__composer-row">
+        <ax-button color="default" look="blank" class="rounded-full" [disabled]="isBusy()">
+          <ax-icon icon="fa-regular fa-sparkles"></ax-icon>
+          <span class="axm-chat-empty-assist-composer__assist-text">
+            @if (selectedAssistLabel(); as assistLabel) {
+              {{ assistLabel | translate | async }}
+            } @else {
+              {{ '@conversation:chat.empty-assist.assist-default' | translate | async }}
+            }
+          </span>
+          @if (!isBusy()) {
+            <ax-dropdown-panel>
+              <ax-button-item-list>
+                @for (row of rows(); track row.id) {
+                  <ax-button-item [text]="(row.title | translate | async)!" [selected]="row.id === selectedAssistId()" (onClick)="onAssistIdChange(row.id)"></ax-button-item>
+                }
+              </ax-button-item-list>
+            </ax-dropdown-panel>
+          }
+        </ax-button>
+
+        @let assistTitle = (selectedAssistLabel() | translate | async) ?? '';
+
+        <textarea
+          #draftInput
+          rows="1"
+          class="axm-chat-empty-assist-composer__textarea border-none outline-none w-full flex-1"
+          [ngModel]="draftText()"
+          (ngModelChange)="draftText.set($event ?? '')"
+          (input)="resizeDraftInput()"
+          (keydown)="onDraftKeydown($event)"
+          [disabled]="isBusy()"
+          [placeholder]="('@conversation:chat.empty-assist.placeholder' | translate: { params: { assist: assistTitle } } | async) ?? ''"
+        ></textarea>
+        <ax-button color="default" class="rounded-full" [disabled]="!canSend()" [text]="sending() ? '…' : ''" [attr.aria-label]="('@conversation:comments.actions.send.title' | translate | async) ?? ''" (onClick)="send()">
+          @if (!sending()) {
+            <ax-icon icon="fa-light fa-arrow-up"></ax-icon>
+          }
+        </ax-button>
+      </div>
+      <axm-assist-suggestion-chips [items]="starterPromptItems()" [compact]="compact()" [sendInPlace]="sendStarterPromptsInPlace()" [disabled]="isBusy()" (conversationCreated)="conversationCreated.emit($event)" />
+    </div>
+  `, isInline: true, styles: [":host{display:block;width:100%}.axm-chat-empty-assist-composer{display:flex;flex-direction:column;gap:1rem;width:min(100%,64rem);margin-inline:auto}.axm-chat-empty-assist-composer__caption{margin-bottom:3rem;text-align:center;font-size:clamp(1.9rem,3.4vw,2.7rem);line-height:1.15;font-weight:700;letter-spacing:-.02em}.axm-chat-empty-assist-composer__composer-row{display:flex;gap:.375rem;align-items:center;padding:.5rem;border-radius:2em;border:1px solid rgb(var(--ax-sys-color-border-lighter-surface))}.axm-chat-empty-assist-composer__assist-text{display:inline-block;max-width:12rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.axm-chat-empty-assist-composer__textarea{resize:none;overflow:hidden;background:transparent;min-height:2.25rem;max-height:14rem;line-height:1.5;padding-block:.25rem;font-size:inherit}:host(.axm-chat-empty-assist-composer-host--compact) .axm-chat-empty-assist-composer{width:100%;max-width:none}:host(.axm-chat-empty-assist-composer-host--compact) .axm-chat-empty-assist-composer__caption{margin-bottom:.75rem;font-size:1.0625rem;line-height:1.35;font-weight:600;letter-spacing:-.01em}:host(.axm-chat-empty-assist-composer-host--compact) .axm-chat-empty-assist-composer__composer-row{gap:.25rem;padding:.375rem .5rem;border-radius:1.5rem}:host(.axm-chat-empty-assist-composer-host--compact) .axm-chat-empty-assist-composer__assist-text{max-width:5.5rem;font-size:.8125rem}:host(.axm-chat-empty-assist-composer-host--compact) .axm-chat-empty-assist-composer__textarea{min-height:1.625rem;max-height:8rem;line-height:1.4;font-size:.875rem;padding-block:.125rem}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox]):not([ngNoCva])[formControlName],textarea:not([ngNoCva])[formControlName],input:not([type=checkbox]):not([ngNoCva])[formControl],textarea:not([ngNoCva])[formControl],input:not([type=checkbox]):not([ngNoCva])[ngModel],textarea:not([ngNoCva])[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "component", type: i2.AXButtonItemComponent, selector: "ax-button-item", inputs: ["color", "disabled", "text", "selected", "divided", "data", "name"], outputs: ["onClick", "onFocus", "onBlur", "disabledChange"] }, { kind: "component", type: i2.AXButtonItemListComponent, selector: "ax-button-item-list", inputs: ["items", "closeParentOnClick", "lockOnLoading"], outputs: ["onItemClick"] }, { kind: "ngmodule", type: AXDropdownModule }, { kind: "component", type: i3.AXDropdownPanelComponent, selector: "ax-dropdown-panel", inputs: ["isOpen", "fitParent", "dropdownWidth", "position", "placement", "_target", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }, { kind: "ngmodule", type: AXTextBoxModule }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i4.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "component", type: AXMAssistSuggestionChipsComponent, selector: "axm-assist-suggestion-chips", inputs: ["items", "compact", "sendInPlace", "disabled"], outputs: ["conversationCreated"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMChatEmptyAssistComposerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-chat-empty-assist-composer', changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        class: 'axm-chat-empty-assist-composer-host',
+                        '[class.axm-chat-empty-assist-composer-host--compact]': 'compact()',
+                    }, imports: [CommonModule, FormsModule, AXButtonModule, AXDropdownModule, AXTextBoxModule, AXDecoratorModule, AXTranslationModule, AXMAssistSuggestionChipsComponent], template: `
+    <div class="axm-chat-empty-assist-composer">
+      <div class="axm-chat-empty-assist-composer__caption">
+        {{ '@conversation:chat.empty-assist.caption' | translate | async }}
+      </div>
+
+      <div class="axm-chat-empty-assist-composer__composer-row">
+        <ax-button color="default" look="blank" class="rounded-full" [disabled]="isBusy()">
+          <ax-icon icon="fa-regular fa-sparkles"></ax-icon>
+          <span class="axm-chat-empty-assist-composer__assist-text">
+            @if (selectedAssistLabel(); as assistLabel) {
+              {{ assistLabel | translate | async }}
+            } @else {
+              {{ '@conversation:chat.empty-assist.assist-default' | translate | async }}
+            }
+          </span>
+          @if (!isBusy()) {
+            <ax-dropdown-panel>
+              <ax-button-item-list>
+                @for (row of rows(); track row.id) {
+                  <ax-button-item [text]="(row.title | translate | async)!" [selected]="row.id === selectedAssistId()" (onClick)="onAssistIdChange(row.id)"></ax-button-item>
+                }
+              </ax-button-item-list>
+            </ax-dropdown-panel>
+          }
+        </ax-button>
+
+        @let assistTitle = (selectedAssistLabel() | translate | async) ?? '';
+
+        <textarea
+          #draftInput
+          rows="1"
+          class="axm-chat-empty-assist-composer__textarea border-none outline-none w-full flex-1"
+          [ngModel]="draftText()"
+          (ngModelChange)="draftText.set($event ?? '')"
+          (input)="resizeDraftInput()"
+          (keydown)="onDraftKeydown($event)"
+          [disabled]="isBusy()"
+          [placeholder]="('@conversation:chat.empty-assist.placeholder' | translate: { params: { assist: assistTitle } } | async) ?? ''"
+        ></textarea>
+        <ax-button color="default" class="rounded-full" [disabled]="!canSend()" [text]="sending() ? '…' : ''" [attr.aria-label]="('@conversation:comments.actions.send.title' | translate | async) ?? ''" (onClick)="send()">
+          @if (!sending()) {
+            <ax-icon icon="fa-light fa-arrow-up"></ax-icon>
+          }
+        </ax-button>
+      </div>
+      <axm-assist-suggestion-chips [items]="starterPromptItems()" [compact]="compact()" [sendInPlace]="sendStarterPromptsInPlace()" [disabled]="isBusy()" (conversationCreated)="conversationCreated.emit($event)" />
+    </div>
+  `, styles: [":host{display:block;width:100%}.axm-chat-empty-assist-composer{display:flex;flex-direction:column;gap:1rem;width:min(100%,64rem);margin-inline:auto}.axm-chat-empty-assist-composer__caption{margin-bottom:3rem;text-align:center;font-size:clamp(1.9rem,3.4vw,2.7rem);line-height:1.15;font-weight:700;letter-spacing:-.02em}.axm-chat-empty-assist-composer__composer-row{display:flex;gap:.375rem;align-items:center;padding:.5rem;border-radius:2em;border:1px solid rgb(var(--ax-sys-color-border-lighter-surface))}.axm-chat-empty-assist-composer__assist-text{display:inline-block;max-width:12rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.axm-chat-empty-assist-composer__textarea{resize:none;overflow:hidden;background:transparent;min-height:2.25rem;max-height:14rem;line-height:1.5;padding-block:.25rem;font-size:inherit}:host(.axm-chat-empty-assist-composer-host--compact) .axm-chat-empty-assist-composer{width:100%;max-width:none}:host(.axm-chat-empty-assist-composer-host--compact) .axm-chat-empty-assist-composer__caption{margin-bottom:.75rem;font-size:1.0625rem;line-height:1.35;font-weight:600;letter-spacing:-.01em}:host(.axm-chat-empty-assist-composer-host--compact) .axm-chat-empty-assist-composer__composer-row{gap:.25rem;padding:.375rem .5rem;border-radius:1.5rem}:host(.axm-chat-empty-assist-composer-host--compact) .axm-chat-empty-assist-composer__assist-text{max-width:5.5rem;font-size:.8125rem}:host(.axm-chat-empty-assist-composer-host--compact) .axm-chat-empty-assist-composer__textarea{min-height:1.625rem;max-height:8rem;line-height:1.4;font-size:.875rem;padding-block:.125rem}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { conversationCreated: [{ type: i0.Output, args: ["conversationCreated"] }], initialAssistId: [{ type: i0.Input, args: [{ isSignal: true, alias: "initialAssistId", required: false }] }], entityId: [{ type: i0.Input, args: [{ isSignal: true, alias: "entityId", required: false }] }], entityType: [{ type: i0.Input, args: [{ isSignal: true, alias: "entityType", required: false }] }], sendStarterPromptsInPlace: [{ type: i0.Input, args: [{ isSignal: true, alias: "sendStarterPromptsInPlace", required: false }] }], compact: [{ type: i0.Input, args: [{ isSignal: true, alias: "compact", required: false }] }], draftInput: [{ type: i0.ViewChild, args: ['draftInput', { isSignal: true }] }] } });
+
+const AXE_CHAT_EMPTY_STATE_PROVIDERS = [
+    {
+        provide: AXM_CHAT_EMPTY_STATE_COMPONENT,
+        useValue: AXMChatEmptyAssistComposerComponent,
+    },
+];
+
+const AXE_MINI_CHAT_INBOX_FILTER_PROVIDERS = [
+    {
+        provide: AXM_MINI_CHAT_INBOX_CONVERSATION_FILTER,
+        useValue: (conversation) => axmConversationHasAiChat(conversation.metadata),
+    },
+];
+
+class AXEAssistDefaultResolver {
+    constructor() {
+        this.aiManager = inject(AXPAiManagerService);
+    }
+    async getDefaultAssistId() {
+        const assist = await this.aiManager.getEffectiveAssist();
+        return assist.id?.trim() || undefined;
+    }
+}
+const AXE_ASSIST_DEFAULT_RESOLVER_PROVIDERS = [
+    AXEAssistDefaultResolver,
+    {
+        provide: AXM_ASSIST_DEFAULT_RESOLVER_PORT,
+        useExisting: AXEAssistDefaultResolver,
+    },
+];
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Helpers ----
+function coerceTimestampMs(value) {
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const parsed = Date.parse(value);
+        return Number.isNaN(parsed) ? 0 : parsed;
+    }
+    return 0;
+}
+//#endregion
+//#region ---- Conversation assist response (SSE subscriber) ----
+/**
+ * Subscribes to server-side assist SSE and forwards message patches to the in-memory realtime bus.
+ * AI generation and entity persistence run on the server ({@link AiConversationAssistResponseService}).
+ */
+class AXEConversationAssistResponseService {
+    constructor() {
+        this.transportService = inject(AXPRuntimeTransportService);
+        this.toastService = inject(AXToastService);
+        this.translation = inject(AXTranslationService);
+        this.store = inject(AXMConversationEntityStoreService);
+        this.focus = inject(AXMConversationFocusService);
+        this.commandService = inject(AXPCommandService);
+        this.injector = inject(Injector);
+        this.messageCache = new Map();
+        this.conversationCache = new Map();
+        this.streamTasks = new Map();
+        this.streamReconnectTimers = new Map();
+        this.lastAssistSyncAt = new Map();
+        this.currentUserId = '';
+        this.composerGenerationConversationId = null;
+        this.cancelAssistRequest = null;
+    }
+    /** Lazy: `AXConversationService` constructs the message API, which injects this port. */
+    get conversationService() {
+        return this.injector.get(AXConversationService);
+    }
+    static { this.ASSIST_SYNC_MIN_INTERVAL_MS = 2000; }
+    async handleAfterUserMessage(conversationId, _userMessageId, _command, currentUserId) {
+        this.currentUserId = currentUserId;
+        this.ensureAssistStreamSubscription(conversationId);
+        const scoped = conversationId.trim();
+        if (!this.conversationCache.has(scoped)) {
+            const storeCached = this.store.getCachedConversation(scoped);
+            if (storeCached) {
+                this.conversationCache.set(scoped, storeCached);
+            }
+        }
+        if (this.focus.isFocused(scoped)) {
+            this.markComposerGenerating(scoped, true);
+        }
+        if (!this.streamTasks.has(scoped)) {
+            void this.requestAssistSync(conversationId, { force: true });
+        }
+    }
+    async retryAssistResponse(conversationId, messageId) {
+        await this.warmConversationCache(conversationId);
+        await this.reconcileStaleAssistPlaceholders(conversationId);
+        const cached = this.messageCache.get(messageId) ?? null;
+        const persisted = await this.store.getMessage(messageId);
+        const message = persisted ?? cached;
+        if (!message) {
+            throw new Error('Message not found');
+        }
+        if (!axmIsAssistRetryableStatus(axmReadAssistResponseStatus(message.metadata))) {
+            throw new Error('Assist response is not retryable');
+        }
+        const replyToUserMessageId = axmReadReplyToUserMessageId(message.metadata);
+        if (!persisted && !replyToUserMessageId) {
+            this.messageCache.delete(messageId);
+            throw new Error('Message not found');
+        }
+        if (!persisted) {
+            this.messageCache.delete(messageId);
+        }
+        this.ensureAssistStreamSubscription(conversationId);
+        if (this.focus.isFocused(conversationId)) {
+            this.markComposerGenerating(conversationId, true);
+        }
+        try {
+            const entity = await this.transportService.execute(AXMAiManagementTransportKeys.ConversationAssist.RetryAssist, {
+                conversationId,
+                messageId,
+                ...(replyToUserMessageId ? { replyToUserMessageId } : {}),
+            });
+            const mapped = axmMessageEntityToMessage(entity);
+            this.applyLiveMessage(mapped, { isNew: false });
+            return mapped;
+        }
+        catch (error) {
+            if (this.focus.isFocused(conversationId)) {
+                this.markComposerGenerating(conversationId, false);
+            }
+            throw error;
+        }
+    }
+    async reconcileStaleAssistPlaceholders(conversationId) {
+        const scoped = conversationId?.trim();
+        if (scoped) {
+            const hasStreaming = await this.hasStreamingAssistPlaceholders(scoped);
+            if (!hasStreaming) {
+                return;
+            }
+            if (!this.conversationCache.has(scoped)) {
+                await this.warmConversationCache(scoped);
+            }
+            // Show any drafts buffered while this chat was unfocused before sync may rewrite status.
+            if (this.focus.isFocused(scoped)) {
+                this.flushLiveCacheToBus(scoped);
+            }
+            this.ensureAssistStreamSubscription(scoped);
+            await this.requestAssistSync(scoped, { force: true });
+        }
+        else {
+            const streaming = await this.store.loadStreamingAssistPlaceholderMessages();
+            for (const message of streaming) {
+                this.messageCache.set(message.id, message);
+            }
+            const conversationIds = new Set(streaming.map((message) => message.conversationId).filter(Boolean));
+            for (const id of conversationIds) {
+                await this.syncAssistMessagesFromStore(id);
+                await this.requestAssistSync(id);
+            }
+        }
+        for (const message of this.messageCache.values()) {
+            if (scoped && message.conversationId !== scoped) {
+                continue;
+            }
+            const status = axmReadAssistResponseStatus(message.metadata);
+            if (status === 'incomplete' && axmAssistPersistedMessageLooksComplete(message)) {
+                await this.repairAssistResponseAsComplete(message);
+                continue;
+            }
+            if (status !== 'streaming') {
+                continue;
+            }
+            if (axmAssistPersistedMessageLooksComplete(message)) {
+                await this.repairAssistResponseAsComplete(message);
+                continue;
+            }
+            this.ensureAssistStreamSubscription(message.conversationId);
+        }
+        if (scoped && this.focus.isFocused(scoped)) {
+            this.flushLiveCacheToBus(scoped);
+        }
+    }
+    getLiveMessage(messageId) {
+        const cached = this.messageCache.get(messageId);
+        return cached ? this.withStreamDraftForDisplay(cached) : null;
+    }
+    async hasStreamingAssistPlaceholders(conversationId) {
+        const scoped = conversationId?.trim();
+        if (!scoped) {
+            return false;
+        }
+        for (const message of this.messageCache.values()) {
+            if (message.conversationId === scoped && axmReadAssistResponseStatus(message.metadata) === 'streaming') {
+                return true;
+            }
+        }
+        const cachedList = this.store.getCachedMessageList(scoped);
+        if (cachedList?.some((message) => axmReadAssistResponseStatus(message.metadata) === 'streaming')) {
+            return true;
+        }
+        const streaming = await this.store.loadStreamingAssistPlaceholderMessages(scoped);
+        return streaming.length > 0;
+    }
+    mergeLiveConversationMessages(conversationId, persisted) {
+        const byId = new Map(persisted.map((message) => [message.id, message]));
+        for (const message of this.messageCache.values()) {
+            if (message.conversationId === conversationId && !message.deleted) {
+                const existing = byId.get(message.id);
+                if (existing && axmShouldPreferPersistedAssistOverLiveCache(existing, message)) {
+                    continue;
+                }
+                byId.set(message.id, this.withStreamDraftForDisplay(message));
+            }
+        }
+        return [...byId.values()].sort((a, b) => axmCompareMessagesChronologically(a, b));
+    }
+    ensureAssistStreamSubscription(conversationId) {
+        const key = conversationId.trim();
+        if (!key || this.streamTasks.has(key)) {
+            return;
+        }
+        const task = this.runAssistStream(key).finally(() => {
+            this.streamTasks.delete(key);
+            // Reattach in the background while placeholders are still streaming (e.g. after leaving the chat).
+            this.scheduleAssistStreamReconnect(key, { allowUnfocused: true });
+        });
+        this.streamTasks.set(key, task);
+    }
+    async runAssistStream(conversationId) {
+        try {
+            await this.transportService.execute(AXMAiManagementTransportKeys.ConversationAssist.Subscribe, {
+                conversationId,
+                onEvent: async (event) => {
+                    await this.handleAssistWireEvent(event);
+                },
+            });
+        }
+        catch (error) {
+            if (this.isBenignAssistStreamClose(conversationId, error)) {
+                return;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            await this.handleAssistStreamTransportFailure(conversationId, message);
+        }
+        finally {
+            await this.syncAssistMessagesFromStore(conversationId);
+        }
+    }
+    async requestAssistSync(conversationId, options) {
+        const key = conversationId.trim();
+        if (!key) {
+            return;
+        }
+        const now = Date.now();
+        const last = this.lastAssistSyncAt.get(key) ?? 0;
+        if (!options?.force && now - last < AXEConversationAssistResponseService.ASSIST_SYNC_MIN_INTERVAL_MS) {
+            return;
+        }
+        this.lastAssistSyncAt.set(key, now);
+        try {
+            const body = await this.transportService.execute(AXMAiManagementTransportKeys.ConversationAssist.AssistSync, { conversationId });
+            const messages = Array.isArray(body.messages) ? body.messages : [];
+            for (const raw of messages) {
+                try {
+                    const mapped = axmMessageEntityToMessage(raw);
+                    this.applyLiveMessage(mapped, { isNew: !this.messageCache.has(mapped.id) });
+                }
+                catch {
+                    // ignore malformed rows
+                }
+            }
+        }
+        catch {
+            // Stream catch-up is best-effort; store sync still runs.
+        }
+    }
+    async handleAssistWireEvent(event) {
+        switch (event.type) {
+            case 'assist_started': {
+                void this.markUserMessageSeenByAssist(event.conversationId, event.userMessageId);
+                const mapped = axmMessageEntityToMessage(event.message);
+                this.applyLiveMessage(mapped, { isNew: !this.messageCache.has(mapped.id) });
+                this.syncComposerGeneratingForConversation(event.conversationId, true);
+                break;
+            }
+            case 'message_patch': {
+                const mapped = axmMessageEntityToMessage(event.message);
+                const isNew = !this.messageCache.has(mapped.id);
+                this.applyLiveMessage(mapped, { isNew });
+                if (axmReadAssistResponseStatus(mapped.metadata) === 'streaming') {
+                    this.syncComposerGeneratingForConversation(mapped.conversationId, true);
+                }
+                else if (axmIsAssistTerminalStatus(axmReadAssistResponseStatus(mapped.metadata))) {
+                    this.syncComposerGeneratingForConversation(mapped.conversationId, false);
+                }
+                break;
+            }
+            case 'conversation_patch': {
+                const syncedRoom = axmRoomWithAssistPeerDisplayName(event.room);
+                const conversation = axmSyncAssistPeerDisplayName(axmRoomEntityToConversation(syncedRoom, this.currentUserId));
+                this.conversationCache.set(conversation.id, conversation);
+                this.store.publishConversationUpdate(conversation);
+                break;
+            }
+            case 'assist_completed': {
+                const mapped = axmMessageEntityToMessage(event.message);
+                this.applyLiveMessage(mapped, { isNew: false });
+                void this.maybeMarkFocusedIncomingRead(mapped);
+                if (event.room) {
+                    this.applyAssistConversationRoomPatch(event.room);
+                }
+                void this.maybeApplyAssistAutoTitleAfterComplete(mapped);
+                this.syncComposerGeneratingForConversation(mapped.conversationId, false);
+                break;
+            }
+            case 'assist_failed': {
+                const mapped = axmMessageEntityToMessage(event.message);
+                this.applyLiveMessage(mapped, { isNew: false });
+                if (this.focus.isFocused(mapped.conversationId)) {
+                    void this.showAssistToast('@conversation:chat.assist.errors.title', event.error);
+                }
+                this.syncComposerGeneratingForConversation(mapped.conversationId, false);
+                break;
+            }
+            case 'frontend_tool_call': {
+                await this.submitFrontendToolResult(event.runId, event.call);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    async submitFrontendToolResult(runId, call) {
+        try {
+            await this.transportService.execute(AXMAiManagementTransportKeys.Engine.SubmitToolResult, { runId, call });
+        }
+        catch (error) {
+            const text = error instanceof Error ? error.message : String(error);
+            void this.showAssistToast('@conversation:chat.assist.errors.tool-title', text);
+        }
+    }
+    async showAssistToast(titleKey, content) {
+        const title = await this.translation.translateAsync(titleKey);
+        this.toastService.show({
+            color: titleKey.includes('stream') ? 'warning' : 'danger',
+            title,
+            content,
+        });
+    }
+    /** Server generates the title via AI; client applies `conversation_patch` / `assist_completed.room`. */
+    async applyAssistAiTitleFromUserText(conversationId, userText) {
+        const scopedId = conversationId.trim();
+        const scopedText = userText.trim();
+        if (!scopedId || !scopedText) {
+            return;
+        }
+        const conversation = this.conversationCache.get(scopedId) ?? (await this.store.getConversation(scopedId));
+        if (!conversation || !axmConversationHasAiChat(conversation.metadata)) {
+            return;
+        }
+        const metadata = (conversation.metadata ?? {});
+        if (metadata['isTitleCustomized'] === true || metadata['isTitleAutoGenerated'] === true) {
+            return;
+        }
+        const assistId = axmExtractAssistIdFromMetadata(metadata);
+        const modelEntityId = typeof metadata['modelEntityId'] === 'string' && metadata['modelEntityId'].trim() ? metadata['modelEntityId'].trim() : undefined;
+        const result = await this.commandService.execute(AIMANAGEMENT_STRUCTURED_TEXT_COMPLETION_COMMAND_KEY, {
+            assistId,
+            modelEntityId,
+            messages: [axpAiChatTextMessage('system', AXM_ASSIST_CONVERSATION_TITLE_SYSTEM_PROMPT), axpAiChatTextMessage('user', scopedText)],
+            maxTokens: 48,
+            temperature: 0.3,
+        });
+        const data = runtimeCommandPayloadData(result);
+        const normalizedTitle = axmSanitizeAiGeneratedConversationTitle(data?.text ?? '');
+        if (!normalizedTitle || normalizedTitle === conversation.title?.trim()) {
+            return;
+        }
+        const updated = axmSyncAssistPeerDisplayName({
+            ...conversation,
+            title: normalizedTitle,
+            metadata: {
+                ...metadata,
+                isTitleCustomized: false,
+                isTitleAutoGenerated: true,
+            },
+        });
+        this.conversationCache.set(updated.id, updated);
+        this.store.publishConversationUpdate(updated);
+    }
+    /** After assist completes — memory update first; entity persist is async and must not block streaming UI. */
+    applyAssistConversationRoomPatch(room) {
+        const syncedRoom = axmRoomWithAssistPeerDisplayName(room);
+        const conversation = axmSyncAssistPeerDisplayName(axmRoomEntityToConversation(syncedRoom, this.currentUserId));
+        this.conversationCache.set(conversation.id, conversation);
+        this.store.publishConversationUpdate(conversation);
+        void this.store.persistAssistTitlePatch(syncedRoom);
+    }
+    /** Client fallback when server room patch is missing or peer display name is still the assist catalog label. */
+    async maybeApplyAssistAutoTitleAfterComplete(assistMessage) {
+        const conversationId = assistMessage.conversationId?.trim();
+        if (!conversationId) {
+            return;
+        }
+        const conversation = this.conversationCache.get(conversationId) ?? (await this.store.getConversation(conversationId));
+        if (!conversation || !axmConversationHasAiChat(conversation.metadata)) {
+            return;
+        }
+        const metadata = (conversation.metadata ?? {});
+        if (metadata['isTitleCustomized'] === true || metadata['isTitleAutoGenerated'] === true) {
+            const peerSynced = axmSyncAssistPeerDisplayName(conversation);
+            if (peerSynced !== conversation) {
+                this.conversationCache.set(peerSynced.id, peerSynced);
+                this.store.publishConversationUpdate(peerSynced);
+            }
+            return;
+        }
+        let userText = '';
+        const replyToId = axmReadReplyToUserMessageId(assistMessage.metadata);
+        if (replyToId) {
+            const userMessage = this.messageCache.get(replyToId) ?? (await this.store.getMessage(replyToId));
+            if (userMessage?.type === 'text') {
+                userText = extractMessageTextFromPayload(userMessage.payload).trim();
+            }
+        }
+        if (!userText) {
+            const cachedMessages = this.store.getCachedMessageList(conversationId);
+            const firstUserText = cachedMessages?.find((message) => !message.deleted && message.senderId === this.currentUserId && message.type === 'text' && extractMessageTextFromPayload(message.payload).trim().length > 0);
+            userText = firstUserText ? extractMessageTextFromPayload(firstUserText.payload).trim() : '';
+        }
+        if (!userText) {
+            const loadedMessages = await this.store.loadConversationMessages(conversationId);
+            const firstUserText = loadedMessages.find((message) => !message.deleted && message.senderId === this.currentUserId && message.type === 'text' && extractMessageTextFromPayload(message.payload).trim().length > 0);
+            userText = firstUserText ? extractMessageTextFromPayload(firstUserText.payload).trim() : '';
+        }
+        if (!userText) {
+            return;
+        }
+        void this.applyAssistAiTitleFromUserText(conversationId, userText);
+    }
+    async markUserMessageSeenByAssist(conversationId, userMessageId) {
+        const scopedId = userMessageId?.trim();
+        if (!scopedId) {
+            return;
+        }
+        const message = this.messageCache.get(scopedId) ?? (await this.store.getMessage(scopedId));
+        if (!message || message.conversationId !== conversationId) {
+            return;
+        }
+        if (message.senderId !== this.currentUserId || message.status === 'read') {
+            return;
+        }
+        await this.store.updateMessage({ ...message, status: 'read' });
+    }
+    async maybeMarkFocusedIncomingRead(message) {
+        const conversationId = message.conversationId?.trim();
+        if (!conversationId || !this.focus.isFocused(conversationId)) {
+            return;
+        }
+        if (message.senderId === this.currentUserId || message.status === 'read') {
+            return;
+        }
+        await this.commandService.execute(CONVERSATION_SYNC_READ_STATE_COMMAND, {
+            conversationId,
+            messageIds: [message.id],
+            currentUserId: this.currentUserId,
+        });
+    }
+    applyLiveMessage(message, options) {
+        const normalized = this.coerceLaggyStreamingTerminal(message);
+        if (this.shouldIgnoreStaleStreamingDowngrade(normalized)) {
+            return;
+        }
+        if (this.shouldIgnoreStaleIncompleteWhileLiveStreaming(normalized)) {
+            return;
+        }
+        if (axmReadAssistResponseStatus(normalized.metadata) === 'streaming' && axmAssistPersistedMessageLooksComplete(normalized)) {
+            void this.repairAssistResponseAsComplete(normalized);
+            return;
+        }
+        // Keep canonical streaming shape in cache (draft stays in metadata); mirror draft only for UI bus.
+        const canonical = this.ensureAssistChronology(normalized);
+        this.messageCache.set(canonical.id, canonical);
+        if (!this.focus.isFocused(canonical.conversationId)) {
+            return;
+        }
+        const forDisplay = this.withStreamDraftForDisplay(canonical);
+        if (options.isNew) {
+            this.store.publishNewMessage(forDisplay);
+            return;
+        }
+        this.store.publishMessageUpdate(forDisplay);
+    }
+    /** Keeps assist bubbles below the linked user turn when client/server clocks disagree. */
+    ensureAssistChronology(message) {
+        const replyToId = axmReadReplyToUserMessageId(message.metadata);
+        if (!replyToId) {
+            return message;
+        }
+        const replyTarget = this.messageCache.get(replyToId);
+        if (!replyTarget) {
+            return message;
+        }
+        return axmEnsureAssistMessageSortsAfterReplyTarget(message, replyTarget.timestamp);
+    }
+    /** Status can lag behind finalize metadata or transcript payload on late patches. */
+    coerceLaggyStreamingTerminal(message) {
+        const status = axmReadAssistResponseStatus(message.metadata);
+        if (status !== 'streaming') {
+            return message;
+        }
+        const meta = message.metadata;
+        const transcripts = meta?.['transcripts'];
+        const hasTranscripts = Array.isArray(transcripts) && transcripts.length > 0;
+        if (!axmAssistHasFinalizeMetadata(meta) && !hasTranscripts) {
+            return message;
+        }
+        const nextMeta = { ...(meta ?? {}) };
+        nextMeta['isStreaming'] = false;
+        nextMeta['assistResponseStatus'] = 'complete';
+        delete nextMeta['assistResponseError'];
+        delete nextMeta['streamDraftText'];
+        delete nextMeta['streamDraftThink'];
+        return { ...message, metadata: nextMeta };
+    }
+    /** Ignore out-of-order streaming patches after a terminal assist state was applied. */
+    shouldIgnoreStaleStreamingDowngrade(incoming) {
+        if (axmReadAssistResponseStatus(incoming.metadata) !== 'streaming') {
+            return false;
+        }
+        if (axmAssistHasFinalizeMetadata(incoming.metadata)) {
+            return false;
+        }
+        const cached = this.messageCache.get(incoming.id);
+        if (!cached) {
+            return false;
+        }
+        const cachedStatus = axmReadAssistResponseStatus(cached.metadata);
+        if (axmIsAssistTerminalStatus(cachedStatus)) {
+            return true;
+        }
+        return axmAssistHasFinalizeMetadata(cached.metadata);
+    }
+    /**
+     * Assist-sync may reclaim a row as incomplete while the live SSE subscription is still
+     * receiving drafts (page refresh / server restart path). Never ignore cancel/supersede.
+     */
+    shouldIgnoreStaleIncompleteWhileLiveStreaming(incoming) {
+        const incomingStatus = axmReadAssistResponseStatus(incoming.metadata);
+        if (incomingStatus !== 'incomplete' && incomingStatus !== 'failed') {
+            return false;
+        }
+        const meta = incoming.metadata;
+        const err = typeof meta?.['assistResponseError'] === 'string' ? meta['assistResponseError'] : '';
+        // Real cancel / provider failures must always win over the live draft cache.
+        if (!err.includes('page refresh or server restart')) {
+            return false;
+        }
+        if (!this.streamTasks.has(incoming.conversationId.trim())) {
+            return false;
+        }
+        const cached = this.messageCache.get(incoming.id);
+        if (!cached || axmReadAssistResponseStatus(cached.metadata) !== 'streaming') {
+            return false;
+        }
+        const cachedMeta = cached.metadata;
+        const incomingMeta = incoming.metadata;
+        const cachedDraft = typeof cachedMeta?.['streamDraftText'] === 'string' ? cachedMeta['streamDraftText'] : '';
+        const incomingDraft = typeof incomingMeta?.['streamDraftText'] === 'string' ? incomingMeta['streamDraftText'] : '';
+        const incomingText = incoming.payload?.type === 'text' ? String(incoming.payload.text ?? '') : '';
+        return cachedDraft.length >= Math.max(incomingDraft.length, incomingText.trim().length);
+    }
+    /** Maps streaming draft metadata into a display-friendly message for the chat renderer. */
+    withStreamDraftForDisplay(message) {
+        const meta = message.metadata;
+        if (axmReadAssistResponseStatus(meta) !== 'streaming') {
+            return message;
+        }
+        const streamDraftText = typeof meta?.['streamDraftText'] === 'string' ? meta['streamDraftText'] : '';
+        if (!streamDraftText.trim()) {
+            return message;
+        }
+        const payload = message.payload;
+        const hasVisibleText = payload?.['type'] === 'text' && typeof payload['text'] === 'string' && payload['text'].trim().length > 0;
+        if (hasVisibleText) {
+            return message;
+        }
+        return {
+            ...message,
+            payload: { type: 'text', text: streamDraftText },
+            metadata: { ...meta },
+        };
+    }
+    async repairAssistResponseAsComplete(message) {
+        const meta = { ...(message.metadata ?? {}) };
+        const streamDraftText = typeof meta['streamDraftText'] === 'string' ? meta['streamDraftText'] : '';
+        const payload = message.payload;
+        const hasPayloadContent = (payload?.['type'] === 'text' && typeof payload['text'] === 'string' && payload['text'].trim().length > 0) || (payload?.['type'] === 'assist-transcript-line' && payload['line'] != null);
+        const next = { ...message };
+        if (!hasPayloadContent && streamDraftText.trim().length > 0) {
+            next.payload = { type: 'text', text: streamDraftText.trim() };
+        }
+        const nextMeta = { ...(next.metadata ?? {}) };
+        nextMeta['isStreaming'] = false;
+        nextMeta['assistResponseStatus'] = 'complete';
+        delete nextMeta['assistResponseError'];
+        delete nextMeta['streamDraftText'];
+        delete nextMeta['streamDraftThink'];
+        next.metadata = nextMeta;
+        this.applyLiveMessage(next, { isNew: false });
+    }
+    async warmConversationCache(conversationId) {
+        if (this.conversationCache.has(conversationId)) {
+            await this.syncAssistMessagesFromStore(conversationId);
+            return;
+        }
+        const conversation = await this.store.getConversation(conversationId);
+        if (conversation) {
+            this.conversationCache.set(conversationId, conversation);
+            if (axmConversationHasAiChat(conversation.metadata)) {
+                this.ensureAssistStreamSubscription(conversationId);
+            }
+        }
+        await this.syncAssistMessagesFromStore(conversationId);
+    }
+    async syncAssistMessagesFromStore(conversationId) {
+        const scoped = conversationId.trim();
+        if (!scoped) {
+            return;
+        }
+        const hasLiveStreaming = [...this.messageCache.values()].some((message) => message.conversationId === scoped && axmReadAssistResponseStatus(message.metadata) === 'streaming');
+        const cachedList = this.store.getCachedMessageList(scoped);
+        const hasCachedStreaming = cachedList?.some((message) => axmReadAssistResponseStatus(message.metadata) === 'streaming') ?? false;
+        const persisted = cachedList && !hasLiveStreaming && !hasCachedStreaming ? cachedList : await this.store.loadConversationMessages(scoped);
+        const persistedIds = new Set(persisted.map((message) => message.id));
+        for (const [id, message] of this.messageCache.entries()) {
+            if (message.conversationId !== scoped || persistedIds.has(id)) {
+                continue;
+            }
+            const status = axmReadAssistResponseStatus(message.metadata);
+            if (axmIsAssistTerminalStatus(status)) {
+                this.messageCache.delete(id);
+            }
+        }
+        for (const message of persisted) {
+            const meta = message.metadata;
+            if (meta?.['isAssistResponse'] !== true && message.type !== 'assist-response') {
+                continue;
+            }
+            const cached = this.messageCache.get(message.id);
+            if (cached && axmShouldPreferPersistedAssistOverLiveCache(message, cached)) {
+                this.messageCache.delete(message.id);
+            }
+            const status = axmReadAssistResponseStatus(message.metadata);
+            if (status === 'streaming') {
+                if (axmAssistPersistedMessageLooksComplete(message)) {
+                    await this.repairAssistResponseAsComplete(message);
+                }
+                else {
+                    this.applyLiveMessage(message, { isNew: !this.messageCache.has(message.id) });
+                }
+                continue;
+            }
+            if (status === 'failed' || status === 'complete' || status === 'incomplete') {
+                this.applyLiveMessage(message, { isNew: false });
+            }
+        }
+    }
+    scheduleAssistStreamReconnect(conversationId, options) {
+        const key = conversationId.trim();
+        if (!key) {
+            return;
+        }
+        if (!options?.allowUnfocused && !this.focus.isFocused(key)) {
+            return;
+        }
+        const hasStreaming = [...this.messageCache.values()].some((message) => message.conversationId === key && axmReadAssistResponseStatus(message.metadata) === 'streaming');
+        if (!hasStreaming) {
+            return;
+        }
+        const existing = this.streamReconnectTimers.get(key);
+        if (existing) {
+            clearTimeout(existing);
+        }
+        const timer = setTimeout(() => {
+            this.streamReconnectTimers.delete(key);
+            if (this.streamTasks.has(key)) {
+                return;
+            }
+            const stillStreaming = [...this.messageCache.values()].some((message) => message.conversationId === key && axmReadAssistResponseStatus(message.metadata) === 'streaming');
+            if (!stillStreaming) {
+                return;
+            }
+            this.ensureAssistStreamSubscription(key);
+        }, 2000);
+        this.streamReconnectTimers.set(key, timer);
+    }
+    isBenignAssistStreamClose(conversationId, error) {
+        if (!this.focus.isFocused(conversationId)) {
+            return true;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        if (message === 'BodyStreamBuffer was aborted') {
+            return true;
+        }
+        return error instanceof DOMException && error.name === 'AbortError';
+    }
+    flushLiveCacheToBus(conversationId) {
+        if (!this.focus.isFocused(conversationId)) {
+            return;
+        }
+        for (const message of this.messageCache.values()) {
+            if (message.conversationId !== conversationId || message.deleted) {
+                continue;
+            }
+            const next = this.withStreamDraftForDisplay(message);
+            this.store.publishMessageUpdate(next);
+        }
+    }
+    async handleAssistStreamTransportFailure(conversationId, errorMessage) {
+        if (!this.focus.isFocused(conversationId)) {
+            return;
+        }
+        await this.syncAssistMessagesFromStore(conversationId);
+        await this.requestAssistSync(conversationId);
+        const stillStreaming = [...this.messageCache.values()].filter((message) => message.conversationId === conversationId && axmReadAssistResponseStatus(message.metadata) === 'streaming');
+        for (const message of stillStreaming) {
+            const meta = { ...(message.metadata ?? {}) };
+            meta['isStreaming'] = false;
+            meta['assistResponseStatus'] = 'incomplete';
+            meta['assistResponseError'] = errorMessage;
+            this.applyLiveMessage({ ...message, metadata: meta }, { isNew: false });
+        }
+        if (stillStreaming.length > 0) {
+            void this.showAssistToast('@conversation:chat.assist.errors.stream-title', errorMessage);
+        }
+        this.syncComposerGeneratingForConversation(conversationId, false);
+    }
+    //#region ----- Composer generation state -----
+    /** Syncs composer Stop / spinner with assist streaming for the focused conversation. */
+    async syncComposerGenerationForFocus(conversationId) {
+        const scoped = conversationId?.trim();
+        if (!scoped) {
+            this.markComposerGenerating(null, false);
+            return;
+        }
+        const hasStreaming = await this.hasStreamingAssistPlaceholders(scoped);
+        this.markComposerGenerating(scoped, hasStreaming);
+    }
+    async cancelAssistGeneration(conversationId) {
+        if (this.cancelAssistRequest) {
+            return this.cancelAssistRequest;
+        }
+        this.cancelAssistRequest = this.runCancelAssistGeneration(conversationId).finally(() => {
+            this.cancelAssistRequest = null;
+        });
+        return this.cancelAssistRequest;
+    }
+    async runCancelAssistGeneration(conversationId) {
+        const scoped = conversationId.trim()
+            || this.composerGenerationConversationId?.trim()
+            || this.resolveActiveStreamingConversationId();
+        if (!scoped) {
+            this.conversationService.cancelGeneration();
+            return;
+        }
+        try {
+            await this.transportService.execute(AXMAiManagementTransportKeys.ConversationAssist.CancelAssist, {
+                conversationId: scoped,
+            });
+            await this.requestAssistSync(scoped, { force: true });
+            await this.syncAssistMessagesFromStore(scoped);
+        }
+        catch (error) {
+            const text = error instanceof Error ? error.message : String(error);
+            if (this.focus.isFocused(scoped)) {
+                void this.showAssistToast('@conversation:chat.assist.errors.stream-title', text);
+            }
+        }
+        finally {
+            this.markComposerGenerating(scoped, false);
+        }
+    }
+    markComposerGenerating(conversationId, generating) {
+        if (generating && conversationId) {
+            this.composerGenerationConversationId = conversationId;
+            if (this.focus.isFocused(conversationId)) {
+                this.conversationService.setGenerating(true);
+            }
+            return;
+        }
+        if (!generating) {
+            this.composerGenerationConversationId = null;
+            if (!conversationId || this.focus.isFocused(conversationId)) {
+                this.conversationService.setGenerating(false);
+            }
+        }
+    }
+    syncComposerGeneratingForConversation(conversationId, generating) {
+        if (!this.focus.isFocused(conversationId)) {
+            return;
+        }
+        this.markComposerGenerating(conversationId, generating);
+    }
+    resolveActiveStreamingConversationId() {
+        for (const message of this.messageCache.values()) {
+            if (axmReadAssistResponseStatus(message.metadata) === 'streaming') {
+                return message.conversationId;
+            }
+        }
+        return this.composerGenerationConversationId;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXEConversationAssistResponseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXEConversationAssistResponseService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXEConversationAssistResponseService, decorators: [{
+            type: Injectable
+        }] });
+/** @deprecated Use {@link AXEConversationAssistResponseService}. */
+const AXCConversationAssistResponseService = AXEConversationAssistResponseService;
+
+class AXMChatWithAssistDialogComponent extends AXBasePageComponent {
+    constructor() {
+        super(...arguments);
+        this.toastService = inject(AXToastService);
+        this.translationService = inject(AXTranslationService);
+        this.assistLauncher = inject(AXMChatAssistLauncherService);
+        this.layoutTheme = inject(AXPLayoutThemeService);
+        this.__popup__ = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "__popup__" }] : /* istanbul ignore next */ []));
+        this.embeddedInTabs = input(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "embeddedInTabs" }] : /* istanbul ignore next */ []));
+        this.rows = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "rows" }] : /* istanbul ignore next */ []));
+        this.loading = signal(true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
+        this.starting = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "starting" }] : /* istanbul ignore next */ []));
+        this.searchQuery = signal('', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "searchQuery" }] : /* istanbul ignore next */ []));
+        this.selectedTargetIds = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedTargetIds" }] : /* istanbul ignore next */ []));
+        this.targetsLoadPromise = null;
+        this.assistListDataSource = new AXDataSource({
+            pageSize: 100,
+            key: 'id',
+            load: async (e) => {
+                await this.ensureTargetsLoaded();
+                const filtered = this.filteredTargetRows();
+                return { items: filtered.slice(e.skip, e.skip + e.take), total: filtered.length };
+            },
+            byKey: (key) => Promise.resolve(this.rows().find((r) => r.id === key) ?? null),
+        });
+        this.assistsListEmptyTpl = viewChild.required('assistsListEmpty', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "assistsListEmptyTpl" }] : /* istanbul ignore next */ []));
+        this.assistsListLoadingTpl = viewChild.required('assistsListLoading', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "assistsListLoadingTpl" }] : /* istanbul ignore next */ []));
+        this.assistsList = viewChild('assistsList', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "assistsList" }] : /* istanbul ignore next */ []));
+        this.syncPopupTitle = effect(() => {
+            if (this.embeddedInTabs())
+                return;
+            const popupRef = this.__popup__();
+            if (popupRef) {
+                this.setTitle = (t) => popupRef.setTitle(t);
+                void this.#updatePopupTitle(popupRef);
+            }
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "syncPopupTitle" }] : /* istanbul ignore next */ []));
+    }
+    targetFromItem(item) {
+        if (!item || typeof item !== 'object')
+            return null;
+        const o = item;
+        if ('data' in o && o['data'] && typeof o['data'] === 'object')
+            return o['data'];
+        if (typeof o['id'] === 'string' && typeof o['name'] === 'string')
+            return o;
+        return null;
+    }
+    onSelectedTargetsChange(value) {
+        if (value == null) {
+            this.selectedTargetIds.set([]);
+            return;
+        }
+        this.selectedTargetIds.set(Array.isArray(value) ? value : [value]);
+    }
+    onSearchChange(value) {
+        this.searchQuery.set(value ?? '');
+        this.assistsList()?.refresh(false);
+    }
+    async ensureTargetsLoaded() {
+        if (!this.targetsLoadPromise)
+            this.targetsLoadPromise = this.loadTargetsFromApi();
+        await this.targetsLoadPromise;
+    }
+    async loadTargetsFromApi() {
+        this.loading.set(true);
+        try {
+            let targets = await this.assistLauncher.loadTargets();
+            if (!targets.length) {
+                targets = await this.assistLauncher.loadTargets(true);
+            }
+            this.rows.set(targets);
+        }
+        catch (error) {
+            console.error('Failed to load AI chat targets:', error);
+            const message = await this.translationService.translateAsync('@conversation:chat.assist-dialog.errors.load-assists');
+            this.toastService.danger(message);
+            this.rows.set([]);
+        }
+        finally {
+            this.loading.set(false);
+            queueMicrotask(() => this.assistsList()?.refresh(false));
+        }
+    }
+    filteredTargetRows() {
+        return axmFilterChatAiTargets((value) => this.translationService.resolve(value), this.rows(), this.searchQuery());
+    }
+    displayName(row) {
+        return axmChatAiTargetDisplayName((value) => this.translationService.resolve(value), row);
+    }
+    targetAvatarUrl(row) {
+        return axmChatAiTargetAvatarUrl(row);
+    }
+    onCancel() {
+        const event = new AXComponentCloseEvent();
+        event.component = this;
+        event.data = null;
+        this.onClosed.emit(event);
+    }
+    async onStartChat() {
+        if (this.starting()) {
+            return;
+        }
+        const targetId = this.selectedTargetIds()[0];
+        if (!targetId) {
+            return;
+        }
+        const row = this.rows().find((r) => r.id === targetId);
+        if (!row) {
+            return;
+        }
+        this.starting.set(true);
+        this.layoutTheme.setOverlayLoading(true);
+        try {
+            // Create + select without route change first. Navigating while the popup is open
+            // destroys this component and unsubscribes `onClosed` → ObjectUnsubscribedError toast.
+            const result = await this.assistLauncher.startAssistChatFromRow(row, false);
+            if (!result?.conversation) {
+                return;
+            }
+            const event = new AXComponentCloseEvent();
+            event.component = this;
+            event.data = result.conversation;
+            this.#emitClosed(event);
+            await this.assistLauncher.navigateToConversation(result.conversation.id);
+        }
+        catch (error) {
+            console.error('Failed to start assist chat:', error);
+            const message = await this.translationService.translateAsync('@conversation:chat.assist-dialog.errors.start-chat');
+            this.toastService.danger(message);
+        }
+        finally {
+            this.starting.set(false);
+            this.layoutTheme.setOverlayLoading(false);
+        }
+    }
+    #emitClosed(event) {
+        try {
+            this.onClosed.emit(event);
+        }
+        catch {
+            // Popup may already be tearing down; conversation was created successfully.
+        }
+    }
+    async #updatePopupTitle(popupRef) {
+        const title = await this.translationService.translateAsync('@conversation:new-conversation.actions.chat-with-ai');
+        popupRef.setTitle(title);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMChatWithAssistDialogComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXMChatWithAssistDialogComponent, isStandalone: true, selector: "axm-chat-with-assist-dialog", inputs: { __popup__: { classPropertyName: "__popup__", publicName: "__popup__", isSignal: true, isRequired: false, transformFunction: null }, embeddedInTabs: { classPropertyName: "embeddedInTabs", publicName: "embeddedInTabs", isSignal: true, isRequired: false, transformFunction: null } }, providers: [{ provide: AXClosableComponent, useExisting: AXMChatWithAssistDialogComponent }], viewQueries: [{ propertyName: "assistsListEmptyTpl", first: true, predicate: ["assistsListEmpty"], descendants: true, isSignal: true }, { propertyName: "assistsListLoadingTpl", first: true, predicate: ["assistsListLoading"], descendants: true, isSignal: true }, { propertyName: "assistsList", first: true, predicate: ["assistsList"], descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
+    <div class="new-conversation-panel">
+      <div class="new-conversation-dialog-content">
+        <div class="form-field form-field--grow">
+          <div class="users-list-wrap">
+            <div class="users-list-search">
+              <ax-search-box [value]="searchQuery()" (valueChange)="onSearchChange($event)" [disabled]="starting()" [placeholder]="('@conversation:chat.assist-dialog.search.placeholder' | translate | async) ?? ''"></ax-search-box>
+            </div>
+            <ax-list
+              #assistsList
+              class="users-list"
+              [dataSource]="assistListDataSource"
+              [multiple]="false"
+              [checkbox]="false"
+              [disabled]="starting()"
+              [valueField]="'id'"
+              [textField]="'name'"
+              [itemHeight]="60"
+              [ngModel]="selectedTargetIds()"
+              (ngModelChange)="onSelectedTargetsChange($event ?? [])"
+              [emptyTemplate]="assistsListEmptyTpl()"
+              [loadingTemplate]="assistsListLoadingTpl()"
+              [itemTemplate]="assistItemTpl"
+            ></ax-list>
+          </div>
+        </div>
+      </div>
+      <ax-footer class="dialog-footer">
+        <ax-suffix>
+          <ax-button [text]="('@conversation:comments.actions.cancel.title' | translate | async) ?? ''" [look]="'solid'" [disabled]="starting()" (onClick)="onCancel()"></ax-button>
+          <ax-button
+            [text]="('@conversation:chat.assist-dialog.actions.start-chat' | translate | async) ?? ''"
+            [look]="'solid'"
+            [color]="'primary'"
+            [disabled]="!selectedTargetIds().length || loading() || starting()"
+            (onClick)="onStartChat()"
+          ></ax-button>
+        </ax-suffix>
+      </ax-footer>
+    </div>
+
+    <ng-template #assistsListEmpty>
+      <div class="users-list-empty">
+        @if (searchQuery()) {
+          {{ '@conversation:chat.assist-dialog.states.no-search-result' | translate | async }}
+        } @else {
+          {{ '@conversation:chat.assist-dialog.states.no-assists' | translate | async }}
+        }
+      </div>
+    </ng-template>
+
+    <ng-template #assistsListLoading>
+      <div class="user-item-skeleton">
+        <ax-skeleton class="skeleton-avatar" [animated]="true"></ax-skeleton>
+        <div class="skeleton-text">
+          <ax-skeleton class="skeleton-name" [animated]="true"></ax-skeleton>
+          <ax-skeleton class="skeleton-description" [animated]="true"></ax-skeleton>
+        </div>
+      </div>
+    </ng-template>
+
+    <ng-template #assistItemTpl let-item>
+      @if (targetFromItem(item); as row) {
+        <div class="user-item-content">
+          <axp-avatar [size]="48" [fullName]="displayName(row)" [src]="targetAvatarUrl(row) ?? ''" />
+          <div class="user-item-text">
+            <span class="truncated user-name-text">{{ row.title | translate | async }}</span>
+            @if (row.description) {
+              <span class="user-description-text truncated">{{ row.description | translate | async }}</span>
+            }
+          </div>
+        </div>
+      }
+    </ng-template>
+  `, isInline: true, styles: [":host{display:block}.new-conversation-panel{display:flex;flex-direction:column;width:100%;overflow:hidden}.new-conversation-dialog-content{flex:1;min-height:0;overflow:hidden;display:flex;flex-direction:column;gap:.75rem}.form-field--grow{flex:1;min-height:0;display:flex;flex-direction:column}.form-field{display:flex;flex-direction:column;gap:.35rem}.users-list-wrap{display:flex;flex-direction:column;height:min(50vh,36rem);overflow:hidden}.users-list-search{flex:0 0 auto;padding:.5rem .75rem;border-bottom:1px solid rgb(var(--ax-sys-color-border-light-surface));background:rgb(var(--ax-sys-color-lighter-surface))}.users-list{display:block;flex:1 1 auto;min-height:0}.user-item-content{display:flex;align-items:center;gap:.75rem;height:100%;padding:.5rem .75rem;min-width:0}.user-item-text{display:flex;flex-direction:column;justify-content:center;min-width:0;flex:1;gap:.125rem}.user-name-text{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.875rem;line-height:1.25rem;font-weight:500;color:rgb(var(--ax-sys-color-on-surface))}.user-description-text{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.875rem;line-height:1.25rem;font-weight:400;opacity:.72;color:rgb(var(--ax-sys-color-on-surface))}.users-list-empty{padding:1rem;text-align:center;font-size:.85rem;opacity:.7}.user-item-skeleton{display:flex;align-items:center;gap:.75rem;height:60px;padding:.5rem 1.25rem;min-width:0}.skeleton-avatar{flex:0 0 auto;width:3rem;height:3rem;border-radius:9999px}.skeleton-text{display:flex;flex-direction:column;min-width:0;flex:1;gap:.5rem}.skeleton-name{height:1rem;width:60%;border-radius:.25rem}.skeleton-description{height:.75rem;width:40%;border-radius:.25rem}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "component", type: AXListComponent, selector: "ax-list", inputs: ["id", "name", "disabled", "readonly", "valueField", "textField", "textTemplate", "disabledField", "multiple", "selectionMode", "isItemTruncated", "showItemTooltip", "dataSource", "itemHeight", "itemTemplate", "emptyTemplate", "loadingTemplate", "checkbox"], outputs: ["onValueChanged", "disabledChange", "readonlyChange", "onBlur", "onFocus", "onItemClick", "onItemSelected", "onScrolledIndexChanged"] }, { kind: "component", type: AXSearchBoxComponent, selector: "ax-search-box", inputs: ["disabled", "readonly", "tabIndex", "placeholder", "value", "state", "name", "id", "look", "class", "delayTime", "type", "autoSearch"], outputs: ["valueChange", "stateChange", "onValueChanged", "onBlur", "onFocus", "readonlyChange", "disabledChange", "onKeyDown", "onKeyUp", "onKeyPress"] }, { kind: "component", type: AXPAvatarComponent, selector: "axp-avatar", inputs: ["size", "src", "fullName", "fallbackText", "placeholder"] }, { kind: "component", type: AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "component", type: AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMChatWithAssistDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-chat-with-assist-dialog', changeDetection: ChangeDetectionStrategy.OnPush, imports: [CommonModule, FormsModule, AXButtonComponent, AXListComponent, AXSearchBoxComponent, AXPAvatarComponent, AXDecoratorGenericComponent, AXSkeletonComponent, AXTranslationModule], providers: [{ provide: AXClosableComponent, useExisting: AXMChatWithAssistDialogComponent }], template: `
+    <div class="new-conversation-panel">
+      <div class="new-conversation-dialog-content">
+        <div class="form-field form-field--grow">
+          <div class="users-list-wrap">
+            <div class="users-list-search">
+              <ax-search-box [value]="searchQuery()" (valueChange)="onSearchChange($event)" [disabled]="starting()" [placeholder]="('@conversation:chat.assist-dialog.search.placeholder' | translate | async) ?? ''"></ax-search-box>
+            </div>
+            <ax-list
+              #assistsList
+              class="users-list"
+              [dataSource]="assistListDataSource"
+              [multiple]="false"
+              [checkbox]="false"
+              [disabled]="starting()"
+              [valueField]="'id'"
+              [textField]="'name'"
+              [itemHeight]="60"
+              [ngModel]="selectedTargetIds()"
+              (ngModelChange)="onSelectedTargetsChange($event ?? [])"
+              [emptyTemplate]="assistsListEmptyTpl()"
+              [loadingTemplate]="assistsListLoadingTpl()"
+              [itemTemplate]="assistItemTpl"
+            ></ax-list>
+          </div>
+        </div>
+      </div>
+      <ax-footer class="dialog-footer">
+        <ax-suffix>
+          <ax-button [text]="('@conversation:comments.actions.cancel.title' | translate | async) ?? ''" [look]="'solid'" [disabled]="starting()" (onClick)="onCancel()"></ax-button>
+          <ax-button
+            [text]="('@conversation:chat.assist-dialog.actions.start-chat' | translate | async) ?? ''"
+            [look]="'solid'"
+            [color]="'primary'"
+            [disabled]="!selectedTargetIds().length || loading() || starting()"
+            (onClick)="onStartChat()"
+          ></ax-button>
+        </ax-suffix>
+      </ax-footer>
+    </div>
+
+    <ng-template #assistsListEmpty>
+      <div class="users-list-empty">
+        @if (searchQuery()) {
+          {{ '@conversation:chat.assist-dialog.states.no-search-result' | translate | async }}
+        } @else {
+          {{ '@conversation:chat.assist-dialog.states.no-assists' | translate | async }}
+        }
+      </div>
+    </ng-template>
+
+    <ng-template #assistsListLoading>
+      <div class="user-item-skeleton">
+        <ax-skeleton class="skeleton-avatar" [animated]="true"></ax-skeleton>
+        <div class="skeleton-text">
+          <ax-skeleton class="skeleton-name" [animated]="true"></ax-skeleton>
+          <ax-skeleton class="skeleton-description" [animated]="true"></ax-skeleton>
+        </div>
+      </div>
+    </ng-template>
+
+    <ng-template #assistItemTpl let-item>
+      @if (targetFromItem(item); as row) {
+        <div class="user-item-content">
+          <axp-avatar [size]="48" [fullName]="displayName(row)" [src]="targetAvatarUrl(row) ?? ''" />
+          <div class="user-item-text">
+            <span class="truncated user-name-text">{{ row.title | translate | async }}</span>
+            @if (row.description) {
+              <span class="user-description-text truncated">{{ row.description | translate | async }}</span>
+            }
+          </div>
+        </div>
+      }
+    </ng-template>
+  `, styles: [":host{display:block}.new-conversation-panel{display:flex;flex-direction:column;width:100%;overflow:hidden}.new-conversation-dialog-content{flex:1;min-height:0;overflow:hidden;display:flex;flex-direction:column;gap:.75rem}.form-field--grow{flex:1;min-height:0;display:flex;flex-direction:column}.form-field{display:flex;flex-direction:column;gap:.35rem}.users-list-wrap{display:flex;flex-direction:column;height:min(50vh,36rem);overflow:hidden}.users-list-search{flex:0 0 auto;padding:.5rem .75rem;border-bottom:1px solid rgb(var(--ax-sys-color-border-light-surface));background:rgb(var(--ax-sys-color-lighter-surface))}.users-list{display:block;flex:1 1 auto;min-height:0}.user-item-content{display:flex;align-items:center;gap:.75rem;height:100%;padding:.5rem .75rem;min-width:0}.user-item-text{display:flex;flex-direction:column;justify-content:center;min-width:0;flex:1;gap:.125rem}.user-name-text{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.875rem;line-height:1.25rem;font-weight:500;color:rgb(var(--ax-sys-color-on-surface))}.user-description-text{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.875rem;line-height:1.25rem;font-weight:400;opacity:.72;color:rgb(var(--ax-sys-color-on-surface))}.users-list-empty{padding:1rem;text-align:center;font-size:.85rem;opacity:.7}.user-item-skeleton{display:flex;align-items:center;gap:.75rem;height:60px;padding:.5rem 1.25rem;min-width:0}.skeleton-avatar{flex:0 0 auto;width:3rem;height:3rem;border-radius:9999px}.skeleton-text{display:flex;flex-direction:column;min-width:0;flex:1;gap:.5rem}.skeleton-name{height:1rem;width:60%;border-radius:.25rem}.skeleton-description{height:.75rem;width:40%;border-radius:.25rem}\n"] }]
+        }], propDecorators: { __popup__: [{ type: i0.Input, args: [{ isSignal: true, alias: "__popup__", required: false }] }], embeddedInTabs: [{ type: i0.Input, args: [{ isSignal: true, alias: "embeddedInTabs", required: false }] }], assistsListEmptyTpl: [{ type: i0.ViewChild, args: ['assistsListEmpty', { isSignal: true }] }], assistsListLoadingTpl: [{ type: i0.ViewChild, args: ['assistsListLoading', { isSignal: true }] }], assistsList: [{ type: i0.ViewChild, args: ['assistsList', { isSignal: true }] }] } });
+
+class AXMChatSidebarAssistAction {
+    constructor() {
+        this.id = 'chat-with-ai';
+        this.label = '@conversation:new-conversation.actions.chat-with-ai';
+        this.icon = 'fa-light fa-robot';
+        this.priority = 20;
+        this.popupService = inject(AXPopupService);
+        this.translationService = inject(AXTranslationService);
+        this.assistLauncher = inject(AXMChatAssistLauncherService);
+    }
+    async run(event) {
+        event?.nativeEvent?.stopPropagation();
+        // Await catalog so the dialog's first AXList load is not racing an empty/incomplete query.
+        await this.assistLauncher.loadTargets();
+        const title = await this.translationService.translateAsync('@conversation:new-conversation.actions.chat-with-ai');
+        await this.popupService.open(AXMChatWithAssistDialogComponent, {
+            title,
+            size: 'sm',
+            closeButton: true,
+        });
+        return null;
+    }
+}
+const AXM_CHAT_SIDEBAR_ASSIST_ACTION_PROVIDERS = [
+    AXMChatSidebarAssistAction,
+    {
+        provide: AXM_CHAT_SIDEBAR_ACTION_PROVIDER,
+        useExisting: AXMChatSidebarAssistAction,
+        multi: true,
+    },
+];
+
+class AXEAIConversationExtensionModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXEAIConversationExtensionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXEAIConversationExtensionModule, imports: [i1$1.AXPComponentSlotModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXEAIConversationExtensionModule, providers: [
+            {
+                provide: AXM_CONVERSATION_ASSIST_RESPONSE_PORT,
+                useClass: AXEConversationAssistResponseService,
+            },
+            {
+                provide: AXM_CHAT_ASSIST_CATALOG_PORT,
+                useExisting: AXMChatAssistCatalogService,
+            },
+            ...AXM_CONVERSATION_ASSIST_BACKGROUND_OPERATION_HANDLERS,
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: AXMConversationAssistSearchProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SEARCH_DEFINITION_PROVIDER,
+                useClass: AXMConversationAssistSearchDefinitionProvider,
+                multi: true,
+            },
+            ...AXE_CHAT_EMPTY_STATE_PROVIDERS,
+            ...AXE_MINI_CHAT_INBOX_FILTER_PROVIDERS,
+            ...AXE_ASSIST_DEFAULT_RESOLVER_PROVIDERS,
+            ...AXM_CHAT_SIDEBAR_ASSIST_ACTION_PROVIDERS,
+            provideAppStartUpTask(() => {
+                const launcher = inject(AXMChatAssistLauncherService);
+                return {
+                    name: 'conversation-assist-catalog-warm',
+                    priority: AXP_APP_STARTUP_PRIORITY.conversationSessionSync + 1,
+                    run: async () => {
+                        void launcher.loadTargets();
+                    },
+                };
+            }),
+            provideCommandSetups([
+                {
+                    key: CONVERSATION_START_ASSIST_CHAT_COMMAND,
+                    command: () => import('./acorex-platform-extension-ai-conversation-client-start-assist-chat.command-BGICtlcW.mjs').then((m) => m.AXMConversationStartAssistChatCommand),
+                },
+                {
+                    key: CONVERSATION_SEND_ASSIST_CHAT_MESSAGE_COMMAND,
+                    command: () => import('./acorex-platform-extension-ai-conversation-client-send-assist-chat-message.command-CMKccVFQ.mjs').then((m) => m.AXMConversationSendAssistChatMessageCommand),
+                },
+            ]),
+        ], imports: [AXPComponentSlotModule.forChild({
+                'root-header-end': [
+                    {
+                        priority: 55,
+                        name: 'conversation-mini-chat',
+                        component: AXMMiniChatHeaderSlotComponent,
+                    },
+                ],
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXEAIConversationExtensionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPComponentSlotModule.forChild({
+                            'root-header-end': [
+                                {
+                                    priority: 55,
+                                    name: 'conversation-mini-chat',
+                                    component: AXMMiniChatHeaderSlotComponent,
+                                },
+                            ],
+                        }),
+                    ],
+                    providers: [
+                        {
+                            provide: AXM_CONVERSATION_ASSIST_RESPONSE_PORT,
+                            useClass: AXEConversationAssistResponseService,
+                        },
+                        {
+                            provide: AXM_CHAT_ASSIST_CATALOG_PORT,
+                            useExisting: AXMChatAssistCatalogService,
+                        },
+                        ...AXM_CONVERSATION_ASSIST_BACKGROUND_OPERATION_HANDLERS,
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: AXMConversationAssistSearchProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_DEFINITION_PROVIDER,
+                            useClass: AXMConversationAssistSearchDefinitionProvider,
+                            multi: true,
+                        },
+                        ...AXE_CHAT_EMPTY_STATE_PROVIDERS,
+                        ...AXE_MINI_CHAT_INBOX_FILTER_PROVIDERS,
+                        ...AXE_ASSIST_DEFAULT_RESOLVER_PROVIDERS,
+                        ...AXM_CHAT_SIDEBAR_ASSIST_ACTION_PROVIDERS,
+                        provideAppStartUpTask(() => {
+                            const launcher = inject(AXMChatAssistLauncherService);
+                            return {
+                                name: 'conversation-assist-catalog-warm',
+                                priority: AXP_APP_STARTUP_PRIORITY.conversationSessionSync + 1,
+                                run: async () => {
+                                    void launcher.loadTargets();
+                                },
+                            };
+                        }),
+                        provideCommandSetups([
+                            {
+                                key: CONVERSATION_START_ASSIST_CHAT_COMMAND,
+                                command: () => import('./acorex-platform-extension-ai-conversation-client-start-assist-chat.command-BGICtlcW.mjs').then((m) => m.AXMConversationStartAssistChatCommand),
+                            },
+                            {
+                                key: CONVERSATION_SEND_ASSIST_CHAT_MESSAGE_COMMAND,
+                                command: () => import('./acorex-platform-extension-ai-conversation-client-send-assist-chat-message.command-CMKccVFQ.mjs').then((m) => m.AXMConversationSendAssistChatMessageCommand),
+                            },
+                        ]),
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMChatAssistLauncherService as A, AXCConversationAssistResponseService as a, AXEAIConversationExtensionModule as b, AXEConversationAssistResponseService as c };
+//# sourceMappingURL=acorex-platform-extension-ai-conversation-client-acorex-platform-extension-ai-conversation-client-ZUV9J76R.mjs.map