@praxisui/page-builder 8.0.0-beta.8 → 8.0.0-beta.9

package/README.md

@@ -116,12 +116,18 @@ providers: [
 
 Fluxo canônico:
 
-- `resolveIntent` envia prompt, pagina atual e widget selecionado para resolver operacao, recurso, schema, surface e elegibilidade.
+- `resolveIntent` envia todo prompt de authoring, pagina atual e widget selecionado para resolver operacao, recurso, schema, surface e elegibilidade no backend canonico. O Page Builder nao deve inferir intencao, recurso ou operacao por heuristica local antes dessa chamada.
 - `previewPage` envia o prompt junto de `intentResolution` elegivel e recebe `MinimalFormPlan` + `CompiledFormPatch`.
+- Hosts podem habilitar `[agenticAuthoringEnableStreaming]="true"` para usar `/api/praxis/config/ai/authoring/turn/stream/**`. O Page Builder consome eventos SSE de progresso e usa o `result` terminal como a mesma fonte de preview; se o endpoint de start ainda nao estiver disponivel, o fluxo pode voltar para `resolveIntent` + `previewPage`. Depois que a conexao SSE e iniciada, erros de transporte sao tolerados por uma janela curta de reconexao e, se persistirem, sao exibidos como falha do stream em vez de disparar uma segunda execucao sincrona silenciosa.
+- Em streaming, a conversa deve refletir estados intermediarios do turno, como resolucao de intencao, selecao de recurso, planejamento e geracao de preview. Nao trate o SSE apenas como transporte do resultado final: cada `PraxisAssistantTurnViewState` emitido precisa atualizar status, mensagens, anexos, respostas rapidas, diagnosticos e preview disponivel.
+- Para cenarios corporativos, mantenha streaming e diagnosticos como capacidades opt-in do host. Streaming melhora feedback percebido em prompts curtos ou ambiguos; diagnosticos exibem prompt/contexto/catalogos e devem ficar restritos a auditoria, suporte ou ambientes controlados.
 - `resolveIntent` e `previewPage` tambem aceitam `sessionId`, `clientTurnId`, `conversationMessages`, `pendingClarification` e `attachmentSummaries` para que respostas curtas e contexto anexado continuem o turno sem reescrever o prompt no frontend.
 - `attachmentSummaries` deve conter apenas metadados serializaveis (`id`, `name`, `kind`, `mimeType`, `sizeBytes`, `source`, `hasPreview`). O frontend nao envia `File`, bytes, base64 nem URLs locais `blob:`. Quando uma pergunta de clarificacao nasce de um turno com anexos, o backend pode ecoar esses resumos em `pendingClarification.diagnostics.attachmentSummaries`; o Page Builder reenvia esse estado no proximo turno.
-- `PageBuilderAiAdapter.applyCompiledFormPatch` aplica somente `compiledFormPatch.patch.page` no runtime do builder.
-- `applyPage` persiste o mesmo `patch.page` em `ui_user_config`, com `componentType`, `componentId`, `scope` e `If-Match` delegados ao backend canônico.
+- Quando `resolveIntent` retornar candidatos ambiguos, o Page Builder deve preservar `quickReplies` como chips clicaveis ricos. Campos como `description`, `icon`, `tone` e `contextHints` pertencem ao contrato do backend e nao devem ser recriados ou descartados no frontend.
+- Hosts podem habilitar `[agenticAuthoringIncludeLlmDiagnostics]="true"` apenas em cenarios de auditoria/debug. O input adiciona `contextHints.includeLlmDiagnostics=true` nas chamadas `resolveIntent` e, quando o backend retorna `llmDiagnostics`, o Page Builder mostra esse JSON em um painel tecnico separado da conversa. O padrao permanece desligado para nao expor prompt/contexto operacional em fluxos comuns.
+- Para criacao de dashboard apos escolha de recurso, `previewPage` pode retornar `uiCompositionPlan.layoutPreset=resource-dashboard`; o builder deve aplicar esse plano como preview de pagina, nao tratar o artefato como fluxo restrito a formulario.
+- `PageBuilderAiAdapter.applyCompiledFormPatch` aplica somente `compiledFormPatch.patch.page` no runtime do builder, materializando uma cópia local antes de atualizar a página.
+- `applyPage` persiste a página renderizável corrente após o preview local em `ui_user_config`, com `componentType`, `componentId`, `scope` e `If-Match` delegados ao backend canônico.
 
 O frontend não deve persistir o envelope completo do patch como payload de runtime. O envelope fica para preview, auditoria e diagnóstico; o documento salvo é a página renderizável.
 

package/fesm2022/praxisui-page-builder.mjs

@@ -25,13 +25,13 @@ import * as i6 from '@angular/material/divider';
 import { MatDividerModule } from '@angular/material/divider';
 import * as i6$1 from '@angular/material/select';
 import { MatSelectModule } from '@angular/material/select';
-import { BehaviorSubject, merge, firstValueFrom } from 'rxjs';
+import { BehaviorSubject, merge, switchMap, Observable, firstValueFrom, from, concatMap, catchError, of, lastValueFrom, tap } from 'rxjs';
 import { SETTINGS_PANEL_DATA } from '@praxisui/settings-panel';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import * as i7 from '@angular/material/tabs';
 import { MatTabsModule } from '@angular/material/tabs';
 import { HttpClient, HttpHeaders } from '@angular/common/http';
-import { PraxisAssistantTurnOrchestratorService, PraxisAiAssistantShellComponent } from '@praxisui/ai';
+import { AI_STREAM_EVENT_TYPES, PraxisAssistantTurnOrchestratorService, PraxisAiAssistantShellComponent } from '@praxisui/ai';
 
 const PLACEHOLDER = 1;
 
@@ -2358,6 +2358,12 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.exploratory.capability.table': 'tables',
     'praxis.pageBuilder.agentic.exploratory.capability.form': 'forms',
     'praxis.pageBuilder.agentic.exploratory.capability.masterDetail': 'master-detail pages',
+    'praxis.pageBuilder.agentic.resourceDiscovery.found': 'I found APIs that can feed this screen. Choose one before generating the preview.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.empty': 'I did not find a matching API yet. Describe the business data this screen should use.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.useResource': 'Use {resourcePath}',
+    'praxis.pageBuilder.agentic.diagnostics.title': 'LLM diagnostics',
+    'praxis.pageBuilder.agentic.diagnostics.badge': 'Debug',
+    'praxis.pageBuilder.agentic.diagnostics.description': 'Prompt, context bundle, and tool catalog returned by the backend for this turn.',
     'praxis.pageBuilder.agentic.dragHandleAria': 'Move AI assistant',
     'praxis.pageBuilder.agentic.resizeHandleAria': 'Resize AI assistant',
     'praxis.pageBuilder.agentic.resizeHandleTooltip': 'Resize',
@@ -2366,7 +2372,10 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.status.resolvingIntent': 'Resolving intent...',
     'praxis.pageBuilder.agentic.status.waitingRevision': 'Refine your prompt and preview again.',
     'praxis.pageBuilder.agentic.status.cancelled': 'Request cancelled.',
+    'praxis.pageBuilder.agentic.status.contextBundle': 'Preparing context...',
+    'praxis.pageBuilder.agentic.status.resourceDiscovery': 'Finding API resources...',
     'praxis.pageBuilder.agentic.status.previewing': 'Generating preview...',
+    'praxis.pageBuilder.agentic.status.previewCompile': 'Compiling preview...',
     'praxis.pageBuilder.agentic.status.previewReady': 'Preview applied to the page.',
     'praxis.pageBuilder.agentic.status.acceptedAddLocalField': 'Local field added to the form.',
     'praxis.pageBuilder.agentic.status.acceptedRemoveLocalField': 'Local field removed from the form.',
@@ -2377,6 +2386,9 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.errors.componentId': 'Configure a component id before saving.',
     'praxis.pageBuilder.agentic.errors.invalidPreview': 'Generated preview is invalid.',
     'praxis.pageBuilder.agentic.errors.intentResolution': 'Intent could not be resolved.',
+    'praxis.pageBuilder.agentic.errors.streamTimeout': 'The assistant took too long to finish this request. Try again with a narrower request or review the active context.',
+    'praxis.pageBuilder.agentic.errors.streamProcessing': 'The assistant could not finish this authoring request. Try again or ask support to review the diagnostics.',
+    'praxis.pageBuilder.agentic.errors.streamConnection': 'The assistant stream was interrupted before the turn finished. Try again or ask support to check the stream connection.',
     'praxis.pageBuilder.agentic.errors.duplicateField': 'This field already exists in the selected form.',
     'praxis.pageBuilder.agentic.errors.nonLocalFieldRemoval': 'Only local fields created by AI can be removed in this flow.',
     'praxis.pageBuilder.agentic.errors.generic': 'AI authoring failed.',
@@ -2599,6 +2611,12 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.exploratory.capability.table': 'tabelas',
     'praxis.pageBuilder.agentic.exploratory.capability.form': 'formulários',
     'praxis.pageBuilder.agentic.exploratory.capability.masterDetail': 'páginas master-detail',
+    'praxis.pageBuilder.agentic.resourceDiscovery.found': 'Encontrei APIs que podem alimentar esta tela. Escolha uma antes de gerar a pré-visualização.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.empty': 'Ainda não encontrei uma API correspondente. Descreva quais dados de negócio esta tela deve usar.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.useResource': 'Usar {resourcePath}',
+    'praxis.pageBuilder.agentic.diagnostics.title': 'Diagnóstico do LLM',
+    'praxis.pageBuilder.agentic.diagnostics.badge': 'Debug',
+    'praxis.pageBuilder.agentic.diagnostics.description': 'Prompt, pacote de contexto e catálogo de ferramentas retornados pelo backend para este turno.',
     'praxis.pageBuilder.agentic.dragHandleAria': 'Mover assistente de IA',
     'praxis.pageBuilder.agentic.resizeHandleAria': 'Redimensionar assistente de IA',
     'praxis.pageBuilder.agentic.resizeHandleTooltip': 'Redimensionar',
@@ -2607,7 +2625,10 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.status.resolvingIntent': 'Resolvendo intenção...',
     'praxis.pageBuilder.agentic.status.waitingRevision': 'Ajuste o prompt e pré-visualize novamente.',
     'praxis.pageBuilder.agentic.status.cancelled': 'Solicitação cancelada.',
+    'praxis.pageBuilder.agentic.status.contextBundle': 'Preparando contexto...',
+    'praxis.pageBuilder.agentic.status.resourceDiscovery': 'Buscando recursos de API...',
     'praxis.pageBuilder.agentic.status.previewing': 'Gerando pré-visualização...',
+    'praxis.pageBuilder.agentic.status.previewCompile': 'Compilando pré-visualização...',
     'praxis.pageBuilder.agentic.status.previewReady': 'Pré-visualização aplicada à página.',
     'praxis.pageBuilder.agentic.status.acceptedAddLocalField': 'Campo local adicionado ao formulário.',
     'praxis.pageBuilder.agentic.status.acceptedRemoveLocalField': 'Campo local removido do formulário.',
@@ -2618,6 +2639,9 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.errors.componentId': 'Configure um id de componente antes de salvar.',
     'praxis.pageBuilder.agentic.errors.invalidPreview': 'A pré-visualização gerada é inválida.',
     'praxis.pageBuilder.agentic.errors.intentResolution': 'A intenção não pôde ser resolvida.',
+    'praxis.pageBuilder.agentic.errors.streamTimeout': 'Ainda não consegui concluir este pedido. Tente novamente com um pedido mais específico ou revise o contexto ativo.',
+    'praxis.pageBuilder.agentic.errors.streamProcessing': 'Não consegui concluir este pedido de autoria. Tente novamente ou peça ao suporte para revisar o diagnóstico.',
+    'praxis.pageBuilder.agentic.errors.streamConnection': 'O stream do assistente foi interrompido antes de concluir o turno. Tente novamente ou acione o suporte para verificar a conexão do stream.',
     'praxis.pageBuilder.agentic.errors.duplicateField': 'Este campo já existe no formulário selecionado.',
     'praxis.pageBuilder.agentic.errors.nonLocalFieldRemoval': 'Somente campos locais criados pela IA podem ser removidos neste fluxo.',
     'praxis.pageBuilder.agentic.errors.generic': 'Falha na autoria com IA.',
@@ -5026,6 +5050,12 @@ class PageBuilderAgenticAuthoringService {
     resolveIntent(request) {
         return this.http.post(`${this.baseUrl}/intent-resolution`, request, { headers: this.buildHeaders() });
     }
+    searchResourceCandidates(request) {
+        return this.http.post(`${this.baseUrl}/resource-candidates`, request, { headers: this.buildHeaders() });
+    }
+    streamTurn(request) {
+        return this.http.post(`${this.baseUrl}/turn/stream/start`, request, { headers: this.buildHeaders() }).pipe(switchMap((start) => this.connectTurnStream(start)));
+    }
     applyPage(request) {
         const { ifMatch, ...body } = request;
         return this.http.post(`${this.baseUrl}/page-apply`, {
@@ -5055,6 +5085,97 @@ class PageBuilderAgenticAuthoringService {
         }
         return new HttpHeaders(merged);
     }
+    connectTurnStream(start) {
+        return new Observable((observer) => {
+            const url = this.buildStreamUrl(start);
+            let source;
+            let closed = false;
+            let connectionErrorTimer = null;
+            const connectionErrorGraceMs = Math.max(0, this.options?.streamConnectionErrorGraceMs ?? 1500);
+            try {
+                source = this.createEventSource(url);
+            }
+            catch (error) {
+                observer.error(this.streamConnectionError(error));
+                return undefined;
+            }
+            const clearConnectionErrorTimer = () => {
+                if (connectionErrorTimer) {
+                    clearTimeout(connectionErrorTimer);
+                    connectionErrorTimer = null;
+                }
+            };
+            const closeSource = () => {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                clearConnectionErrorTimer();
+                source.close();
+            };
+            const failConnection = (event) => {
+                if (closed) {
+                    return;
+                }
+                observer.error(this.streamConnectionError(event));
+                closeSource();
+            };
+            const handleMessage = (event) => {
+                try {
+                    clearConnectionErrorTimer();
+                    const parsed = JSON.parse(event.data);
+                    observer.next(parsed);
+                    if (parsed.type === 'result' || parsed.type === 'error' || parsed.type === 'cancelled') {
+                        observer.complete();
+                        closeSource();
+                    }
+                }
+                catch (error) {
+                    observer.error(this.streamConnectionError(error));
+                    closeSource();
+                }
+            };
+            source.onmessage = handleMessage;
+            if (source.addEventListener) {
+                for (const type of AI_STREAM_EVENT_TYPES) {
+                    source.addEventListener(type, handleMessage);
+                }
+            }
+            source.onerror = (event) => {
+                if (closed || connectionErrorTimer) {
+                    return;
+                }
+                if (connectionErrorGraceMs === 0) {
+                    failConnection(event);
+                    return;
+                }
+                connectionErrorTimer = setTimeout(() => failConnection(event), connectionErrorGraceMs);
+            };
+            return () => closeSource();
+        });
+    }
+    streamConnectionError(cause) {
+        return {
+            praxisAgenticTurnStreamConnectionError: true,
+            cause,
+        };
+    }
+    buildStreamUrl(start) {
+        const url = new URL(`${this.baseUrl}/turn/stream/${start.streamId}`, typeof window !== 'undefined' ? window.location.origin : 'http://localhost');
+        if (start.streamAccessToken) {
+            url.searchParams.set('accessToken', start.streamAccessToken);
+        }
+        return /^https?:\/\//i.test(this.baseUrl)
+            ? url.toString()
+            : url.pathname + url.search;
+    }
+    createEventSource(url) {
+        const factory = this.options?.eventSourceFactory;
+        if (factory) {
+            return factory(url);
+        }
+        return new EventSource(url);
+    }
     formatEtag(etag) {
         const trimmed = etag.trim();
         return trimmed.startsWith('"') ? trimmed : `"${trimmed}"`;
@@ -5387,7 +5508,11 @@ class PageBuilderAiAdapter {
                 error: 'CompiledFormPatch must contain patch.page.',
             };
         }
-        return this.applyPatch({ page }, 'agentic-authoring.compiled-form-patch');
+        const materializedPage = this.clone(page);
+        if (this.shouldPreserveLocalTransientFields(compiledFormPatch)) {
+            this.preserveLocalTransientFields(materializedPage);
+        }
+        return this.applyPatch({ page: materializedPage }, 'agentic-authoring.compiled-form-patch');
     }
     async applyUiCompositionPlan(plan) {
         const compiled = compileUiCompositionPlan(plan);
@@ -5526,6 +5651,76 @@ class PageBuilderAiAdapter {
         }
         return merged;
     }
+    shouldPreserveLocalTransientFields(compiledFormPatch) {
+        const warnings = compiledFormPatch['warnings'];
+        return Array.isArray(warnings) && warnings.includes('server-backed-field-labels-customized-locally');
+    }
+    preserveLocalTransientFields(patchPage) {
+        const basePage = this.normalizePageForAi(this.parsePage(this.host.page));
+        const baseWidgets = basePage?.widgets ?? [];
+        for (const patchWidget of patchPage.widgets ?? []) {
+            if (patchWidget.definition?.id !== 'praxis-dynamic-form')
+                continue;
+            const key = this.getWidgetKey(patchWidget);
+            if (!key)
+                continue;
+            const baseWidget = baseWidgets.find((widget) => this.getWidgetKey(widget) === key);
+            if (!baseWidget)
+                continue;
+            this.preserveLocalTransientFieldsForWidget(baseWidget, patchWidget);
+        }
+    }
+    preserveLocalTransientFieldsForWidget(baseWidget, patchWidget) {
+        const baseConfig = (baseWidget.definition?.inputs?.['config'] ?? {});
+        const patchInputs = patchWidget.definition.inputs ??= {};
+        const patchConfig = (patchInputs['config'] ??= {});
+        const baseFields = Array.isArray(baseConfig['fieldMetadata']) ? baseConfig['fieldMetadata'] : [];
+        const patchFields = Array.isArray(patchConfig['fieldMetadata'])
+            ? patchConfig['fieldMetadata']
+            : (patchConfig['fieldMetadata'] = []);
+        const preservedNames = [];
+        for (const field of baseFields) {
+            if (!this.isLocalTransientField(field) || patchFields.some((entry) => entry?.name === field.name))
+                continue;
+            patchFields.push(this.clone(field));
+            preservedNames.push(field.name);
+        }
+        if (preservedNames.length === 0)
+            return;
+        const baseSections = Array.isArray(baseConfig['sections']) ? baseConfig['sections'] : [];
+        const patchSections = Array.isArray(patchConfig['sections'])
+            ? patchConfig['sections']
+            : (patchConfig['sections'] = []);
+        for (const section of baseSections) {
+            if (!this.sectionContainsAnyField(section, preservedNames))
+                continue;
+            if (this.sectionContainsAnyField({ rows: [{ columns: [{ fields: this.flattenSectionFields(patchSections) }] }] }, preservedNames)) {
+                continue;
+            }
+            patchSections.push(this.clone(section));
+        }
+    }
+    isLocalTransientField(field) {
+        return field?.source === 'local' || field?.transient === true || field?.submitPolicy === 'omit';
+    }
+    sectionContainsAnyField(section, names) {
+        const fields = this.flattenSectionFields([section]);
+        return names.some((name) => fields.includes(name));
+    }
+    flattenSectionFields(sections) {
+        const fields = [];
+        for (const section of sections) {
+            for (const row of section?.rows ?? []) {
+                for (const column of row?.columns ?? []) {
+                    for (const field of column?.fields ?? []) {
+                        if (typeof field === 'string')
+                            fields.push(field);
+                    }
+                }
+            }
+        }
+        return fields;
+    }
     mergeLinks(baseLinks, patchLinks) {
         const base = baseLinks || [];
         const patch = patchLinks || [];
@@ -5717,32 +5912,49 @@ class PageBuilderAgenticAuthoringTurnFlow {
         this.service = service;
         this.context = context;
     }
-    async submit(request) {
+    submit(request) {
         const prompt = request.prompt?.trim();
         if (!prompt) {
-            return {
+            return Promise.resolve({
                 state: 'listening',
                 phase: 'capture',
-            };
+            });
+        }
+        if (this.isResourceDiscoveryTool(request)) {
+            return this.handleResourceDiscoveryTool(request, prompt);
         }
+        if (this.context.enableTurnStream?.() === true && this.service.streamTurn) {
+            return this.submitWithTurnStream(request, prompt);
+        }
+        return this.submitSynchronously(request, prompt);
+    }
+    async submitSynchronously(request, prompt) {
         try {
             const authoringContext = this.buildAuthoringContext(request);
             const componentCapabilities = await this.context.loadComponentCapabilities();
             const selectedWidgetKey = this.context.selectedWidgetKey();
-            const intentResolution = await firstValueFrom(this.service.resolveIntent({
-                userPrompt: prompt,
-                targetApp: this.context.targetApp,
-                targetComponentId: this.context.targetComponentId,
-                currentPage: this.context.currentPage(),
-                selectedWidgetKey,
-                provider: this.context.provider(),
-                model: this.context.model(),
-                apiKey: this.context.apiKey(),
-                componentCapabilities,
-                ...authoringContext,
-            }));
+            const intentResolution = await firstValueFrom(this.service.resolveIntent(this.buildIntentResolutionRequest(prompt, selectedWidgetKey, componentCapabilities, authoringContext)));
             const intentAssistantMessage = this.resolveIntentAssistantMessage(intentResolution);
             if (intentAssistantMessage) {
+                const explicitPendingClarification = this.toShellPendingClarification(intentResolution.pendingClarification);
+                const intentClarification = this.resolveIntentClarification(intentResolution);
+                const pendingClarification = explicitPendingClarification
+                    ?? (intentClarification
+                        ? this.buildPendingClarificationForNextTurn(request, this.resolveEffectivePrompt(intentResolution, prompt), intentClarification)
+                        : null);
+                if (!this.hasPendingClarificationQuestion(pendingClarification)) {
+                    return {
+                        state: 'success',
+                        phase: 'summarize',
+                        assistantMessage: intentAssistantMessage,
+                        quickReplies: this.toShellQuickReplies(intentResolution.quickReplies ?? []),
+                        canApply: false,
+                        statusText: '',
+                        errorText: '',
+                        preview: null,
+                        diagnostics: { intentResolution },
+                    };
+                }
                 return {
                     state: 'clarification',
                     phase: 'clarify',
@@ -5752,7 +5964,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
                     statusText: '',
                     errorText: '',
                     preview: null,
-                    pendingClarification: this.resolvePendingClarificationForNextTurn(intentResolution, request, this.resolveEffectivePrompt(intentResolution, prompt), intentAssistantMessage),
+                    pendingClarification,
                     diagnostics: { intentResolution },
                 };
             }
@@ -5847,6 +6059,11 @@ class PageBuilderAgenticAuthoringTurnFlow {
             };
         }
     }
+    submitWithTurnStream(request, prompt) {
+        return from(this.buildTurnStreamRequest(request, prompt)).pipe(concatMap((streamRequest) => this.service.streamTurn(streamRequest)), concatMap((event) => from(this.toTurnResultFromStreamEvent(event))), catchError((error) => this.shouldFallbackFromTurnStreamError(error)
+            ? from(this.submitSynchronously(request, prompt))
+            : of(this.toTurnStreamTransportErrorResult(error))));
+    }
     async cancel() {
         return {
             state: 'listening',
@@ -5860,10 +6077,317 @@ class PageBuilderAgenticAuthoringTurnFlow {
             pendingPatch: null,
         };
     }
+    async buildTurnStreamRequest(request, prompt) {
+        const componentCapabilities = await this.context.loadComponentCapabilities();
+        const selectedWidgetKey = this.context.selectedWidgetKey();
+        return {
+            userPrompt: prompt,
+            targetApp: this.context.targetApp,
+            targetComponentId: this.context.targetComponentId,
+            currentRoute: null,
+            currentPage: this.context.currentPage(),
+            selectedWidgetKey,
+            provider: this.context.provider(),
+            model: this.context.model(),
+            apiKey: this.context.apiKey(),
+            componentCapabilities,
+            ...this.buildAuthoringContext(request),
+        };
+    }
+    async toTurnResultFromStreamEvent(event) {
+        const payload = this.toJsonObject(event.payload) ?? {};
+        if (event.type === 'result') {
+            return this.toResultTurnFromStreamPayload(payload);
+        }
+        if (event.type === 'error') {
+            const message = this.describeStreamError(payload);
+            return {
+                state: 'error',
+                phase: 'contextualize',
+                assistantMessage: message,
+                canApply: false,
+                statusText: '',
+                errorText: message,
+                preview: null,
+                diagnostics: { streamError: payload },
+            };
+        }
+        if (event.type === 'cancelled') {
+            return {
+                state: 'listening',
+                phase: 'capture',
+                assistantMessage: this.context.tx('agentic.status.cancelled', 'Request cancelled.'),
+                quickReplies: [],
+                canApply: false,
+                statusText: '',
+                errorText: '',
+                preview: null,
+                pendingPatch: null,
+            };
+        }
+        return {
+            state: 'processing',
+            phase: this.phaseForStreamPayload(payload),
+            assistantMessage: undefined,
+            canApply: false,
+            statusText: this.statusForStreamPayload(payload),
+            errorText: '',
+            preview: null,
+        };
+    }
+    async toResultTurnFromStreamPayload(payload) {
+        const intentResolution = payload['intentResolution'];
+        const preview = payload['preview'];
+        if (!intentResolution) {
+            const message = this.context.tx('agentic.errors.intentResolution', 'Intent could not be resolved.');
+            return {
+                state: 'error',
+                phase: 'contextualize',
+                assistantMessage: message,
+                canApply: false,
+                statusText: '',
+                errorText: message,
+                preview: null,
+            };
+        }
+        const assistantMessage = this.readString(payload, 'assistantMessage')
+            || this.resolveIntentAssistantMessage(intentResolution)
+            || (preview ? this.context.describePreviewStatus(preview) : '');
+        const quickReplies = Array.isArray(payload['quickReplies'])
+            ? this.toShellQuickReplies(payload['quickReplies'])
+            : [];
+        const canApply = payload['canApply'] === true && !!preview?.valid;
+        if (!canApply) {
+            const pendingClarification = this.toShellPendingClarification(intentResolution?.pendingClarification);
+            return {
+                state: pendingClarification ? 'clarification' : 'success',
+                phase: pendingClarification ? 'clarify' : 'summarize',
+                assistantMessage,
+                quickReplies,
+                canApply: false,
+                statusText: '',
+                errorText: '',
+                preview: null,
+                pendingClarification,
+                diagnostics: { intentResolution, preview },
+            };
+        }
+        const applied = await this.context.applyLocalPreview(preview);
+        if (!applied.success) {
+            const message = applied.error || this.context.tx('agentic.errors.applyLocal', 'Preview could not be applied.');
+            return {
+                state: 'error',
+                phase: 'preview',
+                assistantMessage: message,
+                canApply: false,
+                statusText: '',
+                errorText: message,
+                preview: null,
+                diagnostics: { intentResolution, preview },
+            };
+        }
+        const status = assistantMessage || this.context.describePreviewStatus(preview);
+        return {
+            state: 'review',
+            phase: 'review',
+            assistantMessage: status,
+            quickReplies,
+            canApply: true,
+            statusText: status,
+            errorText: '',
+            preview,
+            diagnostics: { intentResolution, preview },
+        };
+    }
+    phaseForStreamPayload(payload) {
+        const phase = this.readString(payload, 'phase');
+        if (phase === 'intent.resolve')
+            return 'contextualize';
+        if (phase.startsWith('preview.'))
+            return 'preview';
+        if (phase === 'review')
+            return 'review';
+        return 'contextualize';
+    }
+    statusForStreamPayload(payload) {
+        const phase = this.readString(payload, 'phase');
+        switch (phase) {
+            case 'context.bundle':
+                return this.context.tx('agentic.status.contextBundle', 'Preparing context...');
+            case 'intent.resolve':
+                return this.context.tx('agentic.status.resolvingIntent', 'Resolving intent...');
+            case 'resource.discovery':
+                return this.context.tx('agentic.status.resourceDiscovery', 'Finding API resources...');
+            case 'preview.plan':
+                return this.context.tx('agentic.status.previewing', 'Generating preview...');
+            case 'preview.compile':
+                return this.context.tx('agentic.status.previewCompile', 'Compiling preview...');
+            default:
+                return this.readString(payload, 'summary') || this.readString(payload, 'message');
+        }
+    }
+    describeStreamError(payload) {
+        const code = this.readString(payload, 'code');
+        if (code === 'agentic-authoring-timeout') {
+            return this.context.tx('agentic.errors.streamTimeout', 'The assistant took too long to finish this request. Try again with a narrower request or review the active context.');
+        }
+        if (code === 'agentic-authoring-processing-failed') {
+            return this.context.tx('agentic.errors.streamProcessing', 'The assistant could not finish this authoring request. Try again or ask support to review the diagnostics.');
+        }
+        return this.readString(payload, 'assistantMessage')
+            || this.context.tx('agentic.errors.generic', 'AI authoring failed.');
+    }
+    toTurnStreamTransportErrorResult(error) {
+        const message = this.isTurnStreamConnectionError(error)
+            ? this.context.tx('agentic.errors.streamConnection', 'The assistant stream was interrupted before the turn finished. Try again or ask support to check the stream connection.')
+            : this.context.describeError(error);
+        return {
+            state: 'error',
+            phase: 'contextualize',
+            assistantMessage: message,
+            canApply: false,
+            statusText: '',
+            errorText: message,
+            preview: null,
+            diagnostics: { streamTransportError: this.toJsonObject(error) ?? { reason: 'stream-transport-error' } },
+        };
+    }
+    shouldFallbackFromTurnStreamError(error) {
+        if (this.isTurnStreamConnectionError(error)) {
+            return false;
+        }
+        const status = this.readErrorStatus(error);
+        if (status === 401 || status === 403) {
+            return false;
+        }
+        return status === 404 || status === 501 || status === 503;
+    }
+    isTurnStreamConnectionError(error) {
+        return this.toJsonObject(error)?.['praxisAgenticTurnStreamConnectionError'] === true;
+    }
+    readErrorStatus(error) {
+        const status = this.toJsonObject(error)?.['status'];
+        return typeof status === 'number' && Number.isFinite(status) ? status : null;
+    }
+    async handleResourceDiscoveryTool(request, prompt) {
+        const contextHints = this.toJsonObject(request.action?.contextHints) ?? {};
+        const retrievalQuery = this.readString(contextHints, 'retrievalQuery') || prompt;
+        const artifactKind = this.readString(contextHints, 'artifactKind') || null;
+        const limit = this.readNumber(contextHints, 'limit');
+        const result = await firstValueFrom(this.service.searchResourceCandidates({
+            retrievalQuery,
+            userPrompt: prompt,
+            artifactKind,
+            limit,
+        }));
+        const quickReplies = this.toResourceCandidateQuickReplies(result.candidates, result.artifactKind);
+        const assistantMessage = quickReplies.length
+            ? this.context.tx('agentic.resourceDiscovery.found', 'I found APIs that can feed this screen. Choose one before generating the preview.')
+            : this.context.tx('agentic.resourceDiscovery.empty', 'I did not find a matching API yet. Describe the business data this screen should use.');
+        return {
+            state: 'clarification',
+            phase: 'clarify',
+            assistantMessage,
+            quickReplies,
+            canApply: false,
+            statusText: '',
+            errorText: '',
+            preview: null,
+            pendingClarification: {
+                sourcePrompt: request.pendingClarification?.sourcePrompt || prompt,
+                assistantMessage,
+                questions: [
+                    {
+                        id: 'resource',
+                        type: 'text',
+                        label: assistantMessage,
+                    },
+                ],
+                clientTurnId: request.clientTurnId,
+                diagnostics: {
+                    resourceDiscovery: {
+                        tool: result.tool,
+                        retrievalQuery: result.retrievalQuery,
+                        artifactKind: result.artifactKind,
+                        warnings: result.warnings,
+                    },
+                },
+            },
+            diagnostics: { resourceDiscovery: result },
+        };
+    }
+    isResourceDiscoveryTool(request) {
+        const contextHints = this.toJsonObject(request.action?.contextHints);
+        return this.readString(contextHints, 'tool') === 'searchApiResources';
+    }
+    toResourceCandidateQuickReplies(candidates, artifactKind) {
+        return candidates
+            .filter((candidate) => !!candidate.resourcePath?.trim())
+            .map((candidate) => {
+            const resourcePath = candidate.resourcePath.trim();
+            const submitUrl = candidate.submitUrl?.trim() || resourcePath;
+            return {
+                id: this.resourceCandidateId(resourcePath),
+                kind: 'suggestion',
+                label: this.resourceCandidateLabel(resourcePath),
+                prompt: this.formatResourceCandidatePrompt(resourcePath),
+                description: this.resourceCandidateDescription(candidate),
+                icon: 'dataset',
+                tone: 'resource',
+                contextHints: {
+                    resourcePath,
+                    submitUrl,
+                    operation: candidate.operation,
+                    schemaUrl: candidate.schemaUrl,
+                    submitMethod: candidate.submitMethod,
+                    artifactKind,
+                },
+            };
+        });
+    }
+    formatResourceCandidatePrompt(resourcePath) {
+        return this.context
+            .tx('agentic.resourceDiscovery.useResource', 'Use {resourcePath}')
+            .replace('{resourcePath}', resourcePath);
+    }
+    resourceCandidateId(resourcePath) {
+        const slug = resourcePath
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '');
+        return slug ? `resource-${slug}` : 'resource-candidate';
+    }
+    resourceCandidateLabel(resourcePath) {
+        const segment = resourcePath.split('/').filter((part) => !!part).pop() || resourcePath;
+        const label = segment
+            .replace(/[-_]+/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+        return label
+            ? label.charAt(0).toUpperCase() + label.slice(1)
+            : resourcePath;
+    }
+    resourceCandidateDescription(candidate) {
+        const method = candidate.submitMethod?.trim();
+        const url = candidate.submitUrl?.trim();
+        return method && url ? `${method} ${url}` : url || undefined;
+    }
     resolveIntentAssistantMessage(intentResolution) {
+        if (this.isExecutableIntent(intentResolution)) {
+            return null;
+        }
         const message = intentResolution.assistantMessage?.trim();
         return message || null;
     }
+    isExecutableIntent(intentResolution) {
+        const operationKind = intentResolution.operationKind;
+        const artifactKind = intentResolution.artifactKind;
+        return !!intentResolution.valid
+            && intentResolution.gate?.status === 'eligible'
+            && !!intentResolution.selectedCandidate
+            && (artifactKind === 'form' || artifactKind === 'dashboard' || artifactKind === 'table' || artifactKind === 'page')
+            && (operationKind === 'create' || operationKind === 'modify' || operationKind === 'remove' || operationKind === 'compose');
+    }
     resolveIntentClarification(intentResolution) {
         const questions = intentResolution.clarificationQuestions?.filter((question) => !!question) ?? [];
         if (!intentResolution.valid && questions.length) {
@@ -5872,7 +6396,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
         return null;
     }
     describeIntentResolutionFailure(intentResolution) {
-        if (intentResolution.valid && intentResolution.gate?.status === 'eligible' && intentResolution.selectedCandidate) {
+        if (this.isExecutableIntent(intentResolution)) {
             return null;
         }
         const questions = intentResolution.clarificationQuestions?.filter((question) => !!question) ?? [];
@@ -5897,6 +6421,10 @@ class PageBuilderAgenticAuthoringTurnFlow {
             kind: reply.kind,
             label: reply.label,
             prompt: reply.prompt,
+            description: reply.description,
+            icon: reply.icon,
+            tone: reply.tone,
+            contextHints: this.toJsonObject(reply.contextHints),
         }));
     }
     buildPendingClarificationForNextTurn(request, sourcePrompt, clarification) {
@@ -5947,16 +6475,47 @@ class PageBuilderAgenticAuthoringTurnFlow {
             diagnostics: this.toJsonObject(pending?.diagnostics) ?? undefined,
         };
     }
+    hasPendingClarificationQuestion(pending) {
+        return !!pending?.sourcePrompt?.trim() && pending.questions.some((question) => !!question.label?.trim());
+    }
     resolveEffectivePrompt(intentResolution, fallbackPrompt) {
         return intentResolution.effectivePrompt?.trim() || fallbackPrompt;
     }
     buildAuthoringContext(request) {
+        const contextHints = this.buildContextHints(request);
         return {
             sessionId: request.sessionId,
             clientTurnId: request.clientTurnId,
             conversationMessages: this.toConversationMessages(request.messages ?? []),
             pendingClarification: this.toPendingClarification(request.pendingClarification),
             attachmentSummaries: this.toAttachmentSummaries(request.attachments ?? []),
+            contextHints,
+        };
+    }
+    buildIntentResolutionRequest(prompt, selectedWidgetKey, componentCapabilities, authoringContext) {
+        return {
+            userPrompt: prompt,
+            targetApp: this.context.targetApp,
+            targetComponentId: this.context.targetComponentId,
+            currentPage: this.context.currentPage(),
+            selectedWidgetKey,
+            provider: this.context.provider(),
+            model: this.context.model(),
+            apiKey: this.context.apiKey(),
+            componentCapabilities,
+            ...authoringContext,
+        };
+    }
+    buildContextHints(request) {
+        const base = this.toJsonObject(request.action?.contextHints)
+            ?? this.toJsonObject(request.contextHints);
+        const includeLlmDiagnostics = this.context.includeLlmDiagnostics?.() === true;
+        if (!includeLlmDiagnostics) {
+            return base ?? undefined;
+        }
+        return {
+            ...(base ?? {}),
+            includeLlmDiagnostics: true,
         };
     }
     toAttachmentSummaries(attachments) {
@@ -6005,6 +6564,14 @@ class PageBuilderAgenticAuthoringTurnFlow {
             ? value
             : null;
     }
+    readString(value, key) {
+        const raw = value?.[key];
+        return typeof raw === 'string' ? raw.trim() : '';
+    }
+    readNumber(value, key) {
+        const raw = value?.[key];
+        return typeof raw === 'number' && Number.isFinite(raw) ? raw : null;
+    }
 }
 
 function buildConnectionsViewerModel(page) {
@@ -6522,6 +7089,8 @@ class DynamicPageBuilderComponent {
     agenticAuthoringComponentId;
     agenticAuthoringScope = 'user';
     agenticAuthoringEtag;
+    agenticAuthoringIncludeLlmDiagnostics = false;
+    agenticAuthoringEnableStreaming = false;
     pageChange = new EventEmitter();
     agenticAuthoringApplied = new EventEmitter();
     currentPage = signal({ widgets: [] }, ...(ngDevMode ? [{ debugName: "currentPage" }] : []));
@@ -6536,6 +7105,7 @@ class DynamicPageBuilderComponent {
     agenticAuthoringConversation = signal([], ...(ngDevMode ? [{ debugName: "agenticAuthoringConversation" }] : []));
     agenticAuthoringQuickReplies = signal([], ...(ngDevMode ? [{ debugName: "agenticAuthoringQuickReplies" }] : []));
     agenticAuthoringAttachments = signal([], ...(ngDevMode ? [{ debugName: "agenticAuthoringAttachments" }] : []));
+    agenticAuthoringLlmDiagnostics = signal(null, ...(ngDevMode ? [{ debugName: "agenticAuthoringLlmDiagnostics" }] : []));
     agenticAuthoringEditingMessageId = signal(null, ...(ngDevMode ? [{ debugName: "agenticAuthoringEditingMessageId" }] : []));
     agenticAuthoringPanelLayout = signal({
         left: 16,
@@ -6568,6 +7138,7 @@ class DynamicPageBuilderComponent {
         this.previewMode = !this.previewMode;
         if (this.previewMode) {
             this.connectionsViewerOpen.set(false);
+            this.agenticAuthoringLlmDiagnostics.set(null);
         }
     }
     toggleConnectionsViewer() {
@@ -6728,11 +7299,10 @@ class DynamicPageBuilderComponent {
         try {
             const controller = this.ensureAgenticTurnController();
             const editingMessageId = this.agenticAuthoringEditingMessageId();
-            const state = await firstValueFrom(editingMessageId
+            await this.consumeAgenticTurn(editingMessageId
                 ? controller.submitEditedMessage(editingMessageId, prompt)
                 : controller.submitPrompt(prompt));
             this.agenticAuthoringEditingMessageId.set(null);
-            this.applyAgenticTurnState(state);
         }
         catch (error) {
             this.agenticAuthoringStatus.set('');
@@ -6750,8 +7320,7 @@ class DynamicPageBuilderComponent {
         }
         if (reply.kind === 'cancel') {
             this.agenticAuthoringEditingMessageId.set(null);
-            const state = await firstValueFrom(this.ensureAgenticTurnController().cancel());
-            this.applyAgenticTurnState(state);
+            await this.consumeAgenticTurn(this.ensureAgenticTurnController().cancel());
             return;
         }
         if (reply.kind === 'revise') {
@@ -6762,7 +7331,37 @@ class DynamicPageBuilderComponent {
         }
         this.agenticAuthoringEditingMessageId.set(null);
         this.agenticAuthoringPrompt.set(reply.prompt);
-        await this.previewAgenticAuthoring();
+        this.agenticAuthoringBusy.set(true);
+        this.agenticAuthoringError.set('');
+        this.agenticAuthoringPreviewResult.set(null);
+        this.agenticAuthoringStatus.set(this.tx('agentic.status.resolvingIntent', 'Resolving intent...'));
+        try {
+            const controller = this.ensureAgenticTurnController();
+            const contextHints = reply.contextHints ? { ...reply.contextHints } : undefined;
+            await this.consumeAgenticTurn(controller.snapshot().state === 'clarification'
+                ? controller.answerClarification({
+                    id: reply.id,
+                    label: reply.prompt,
+                    value: reply.prompt,
+                    description: reply.description ?? undefined,
+                    contextHints,
+                })
+                : controller.submitPrompt(reply.prompt, {
+                    kind: reply.kind || 'quick-reply',
+                    id: reply.id,
+                    value: reply.prompt,
+                    contextHints,
+                }));
+        }
+        catch (error) {
+            this.agenticAuthoringStatus.set('');
+            const message = this.describeAgenticError(error);
+            this.agenticAuthoringError.set(message);
+            this.appendAgenticMessage('error', message);
+        }
+        finally {
+            this.agenticAuthoringBusy.set(false);
+        }
     }
     attachAgenticContext() {
         const controller = this.ensureAgenticTurnController();
@@ -6807,8 +7406,7 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringError.set('');
         this.agenticAuthoringPreviewResult.set(null);
         try {
-            const state = await firstValueFrom(this.ensureAgenticTurnController().resendMessage(message.id));
-            this.applyAgenticTurnState(state);
+            await this.consumeAgenticTurn(this.ensureAgenticTurnController().resendMessage(message.id));
         }
         catch (error) {
             this.agenticAuthoringStatus.set('');
@@ -6877,6 +7475,8 @@ class DynamicPageBuilderComponent {
                 provider: () => this.agenticAuthoringProvider,
                 model: () => this.agenticAuthoringModel,
                 apiKey: () => this.agenticAuthoringApiKey,
+                enableTurnStream: () => this.agenticAuthoringEnableStreaming,
+                includeLlmDiagnostics: () => this.agenticAuthoringIncludeLlmDiagnostics,
                 loadComponentCapabilities: () => this.loadAgenticComponentCapabilities(),
                 applyLocalPreview: (result) => this.applyAgenticPreviewLocally(result),
                 describePreviewFailure: (result) => this.describeAgenticPreviewFailure(result),
@@ -6909,9 +7509,36 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringError.set(state.errorText);
         this.agenticAuthoringPreviewResult.set(state.preview ?? null);
         this.agenticAuthoringAttachments.set(state.attachments);
+        this.agenticAuthoringLlmDiagnostics.set(this.resolveAgenticLlmDiagnostics(state.diagnostics));
+    }
+    consumeAgenticTurn(states$) {
+        return lastValueFrom(states$.pipe(tap((state) => this.applyAgenticTurnState(state))));
+    }
+    agenticAuthoringDiagnosticsTop() {
+        return Math.max(16, this.agenticAuthoringPanelLayout().top);
+    }
+    agenticAuthoringLlmDiagnosticsText() {
+        const diagnostics = this.agenticAuthoringLlmDiagnostics();
+        if (!this.agenticAuthoringIncludeLlmDiagnostics || !diagnostics) {
+            return '';
+        }
+        return JSON.stringify(diagnostics, null, 2);
+    }
+    resolveAgenticLlmDiagnostics(diagnostics) {
+        if (!this.agenticAuthoringIncludeLlmDiagnostics) {
+            return null;
+        }
+        const intentResolution = this.toRecord(diagnostics?.['intentResolution']);
+        return this.toRecord(intentResolution?.['llmDiagnostics']);
+    }
+    toRecord(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return null;
+        }
+        return value;
     }
     resolvePreviewCompiledFormPatch(preview) {
-        if (preview.uiCompositionPlan) {
+        if (preview.uiCompositionPlan || preview.compiledFormPatch?.patch?.page) {
             return {
                 ...preview.compiledFormPatch,
                 patch: {
@@ -6920,9 +7547,6 @@ class DynamicPageBuilderComponent {
                 },
             };
         }
-        if (preview.compiledFormPatch?.patch?.page) {
-            return preview.compiledFormPatch;
-        }
         return preview.compiledFormPatch;
     }
     focusCanvasWidget(widgetKey) {
@@ -7043,7 +7667,7 @@ class DynamicPageBuilderComponent {
         return resolvePraxisPageBuilderText(this.i18n, key, fallback);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DynamicPageBuilderComponent, deps: [{ token: i1.MatDialog }, { token: SETTINGS_PANEL_BRIDGE, optional: true }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.17", type: DynamicPageBuilderComponent, isStandalone: true, selector: "praxis-dynamic-page-builder", inputs: { page: "page", context: "context", strictValidation: "strictValidation", autoPersist: "autoPersist", enableCustomization: "enableCustomization", showSettingsButton: "showSettingsButton", pageIdentity: "pageIdentity", componentInstanceId: "componentInstanceId", pageEditorComponent: "pageEditorComponent", enableAgenticAuthoring: "enableAgenticAuthoring", agenticAuthoringProvider: "agenticAuthoringProvider", agenticAuthoringModel: "agenticAuthoringModel", agenticAuthoringApiKey: "agenticAuthoringApiKey", agenticAuthoringComponentId: "agenticAuthoringComponentId", agenticAuthoringScope: "agenticAuthoringScope", agenticAuthoringEtag: "agenticAuthoringEtag" }, outputs: { pageChange: "pageChange", agenticAuthoringApplied: "agenticAuthoringApplied" }, providers: [
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.17", type: DynamicPageBuilderComponent, isStandalone: true, selector: "praxis-dynamic-page-builder", inputs: { page: "page", context: "context", strictValidation: "strictValidation", autoPersist: "autoPersist", enableCustomization: "enableCustomization", showSettingsButton: "showSettingsButton", pageIdentity: "pageIdentity", componentInstanceId: "componentInstanceId", pageEditorComponent: "pageEditorComponent", enableAgenticAuthoring: "enableAgenticAuthoring", agenticAuthoringProvider: "agenticAuthoringProvider", agenticAuthoringModel: "agenticAuthoringModel", agenticAuthoringApiKey: "agenticAuthoringApiKey", agenticAuthoringComponentId: "agenticAuthoringComponentId", agenticAuthoringScope: "agenticAuthoringScope", agenticAuthoringEtag: "agenticAuthoringEtag", agenticAuthoringIncludeLlmDiagnostics: "agenticAuthoringIncludeLlmDiagnostics", agenticAuthoringEnableStreaming: "agenticAuthoringEnableStreaming" }, outputs: { pageChange: "pageChange", agenticAuthoringApplied: "agenticAuthoringApplied" }, providers: [
             providePraxisPageBuilderI18n(),
             { provide: DYNAMIC_PAGE_SHELL_EDITOR, useValue: WidgetShellEditorComponent },
         ], viewQueries: [{ propertyName: "runtime", first: true, predicate: ["runtime"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
@@ -7107,6 +7731,26 @@ class DynamicPageBuilderComponent {
         (close)="toggleAgenticAuthoring()"
       />
 
+      <section
+        *ngIf="agenticAuthoringIncludeLlmDiagnostics && agenticAuthoringLlmDiagnosticsText()"
+        class="agentic-diagnostics-panel"
+        data-testid="page-builder-agentic-llm-diagnostics"
+        role="region"
+        [attr.aria-label]="tx('agentic.diagnostics.title', 'LLM diagnostics')"
+        [style.top.px]="agenticAuthoringDiagnosticsTop()"
+      >
+        <header class="agentic-diagnostics-panel__header">
+          <span>{{ tx('agentic.diagnostics.title', 'LLM diagnostics') }}</span>
+          <span class="agentic-diagnostics-panel__badge">
+            {{ tx('agentic.diagnostics.badge', 'Debug') }}
+          </span>
+        </header>
+        <p class="agentic-diagnostics-panel__description">
+          {{ tx('agentic.diagnostics.description', 'Prompt, context bundle, and tool catalog returned by the backend for this turn.') }}
+        </p>
+        <pre>{{ agenticAuthoringLlmDiagnosticsText() }}</pre>
+      </section>
+
       <praxis-floating-toolbar
         [visible]="showSettings()"
         [canUndo]="false"
@@ -7141,7 +7785,7 @@ class DynamicPageBuilderComponent {
         </button>
       </praxis-floating-toolbar>
     </div>
-  `, isInline: true, styles: [":host{display:block;position:relative;min-height:var(--pdx-page-builder-min-height, 420px)}.builder-shell{display:block;position:relative;min-height:inherit;height:100%}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.MatMiniFabButton, selector: "button[mat-mini-fab], a[mat-mini-fab], button[matMiniFab], a[matMiniFab]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i3.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }, { kind: "component", type: DynamicWidgetPageComponent, selector: "praxis-dynamic-page", inputs: ["page", "context", "strictValidation", "enableCustomization", "showPageSettingsButton", "shellEditorComponent", "pageEditorComponent", "autoPersist", "pageIdentity", "componentInstanceId"], outputs: ["pageChange", "widgetEvent", "widgetDiagnosticsChange"] }, { kind: "component", type: FloatingToolbarComponent, selector: "praxis-floating-toolbar", inputs: ["visible", "canUndo", "canRedo"], outputs: ["add", "undo", "redo", "settings", "preview", "save"] }, { kind: "component", type: ConnectionsViewerPanelComponent, selector: "praxis-connections-viewer-panel", inputs: ["open", "page"], outputs: ["focusWidget", "openPageSettings"] }, { kind: "component", type: PraxisAiAssistantShellComponent, selector: "praxis-ai-assistant-shell", inputs: ["labels", "mode", "state", "contextItems", "attachments", "messages", "quickReplies", "prompt", "statusText", "errorText", "testIdPrefix", "panelTestId", "submitTestId", "applyTestId", "busy", "canSubmit", "canApply", "submitOnEnter", "enableFileAttachments", "attachmentAccept", "attachmentMultiple", "draggable", "resizable", "minWidth", "minHeight", "margin", "layout"], outputs: ["promptChange", "submitPrompt", "apply", "close", "attach", "attachmentsPasted", "attachmentsSelected", "removeAttachment", "messageAction", "editMessage", "resendMessage", "quickReply", "layoutChange"] }] });
+  `, isInline: true, styles: [":host{display:block;position:relative;min-height:var(--pdx-page-builder-min-height, 420px)}.builder-shell{display:block;position:relative;min-height:inherit;height:100%}.agentic-diagnostics-panel{position:absolute;z-index:21;right:16px;width:min(520px,calc(100% - 32px));max-height:min(440px,calc(100% - 32px));overflow:auto;padding:12px;border:1px solid rgba(107,114,128,.28);border-radius:8px;background:#fffffff5;color:#111827;box-shadow:0 14px 36px #0000003d}.agentic-diagnostics-panel__header{display:flex;align-items:center;justify-content:space-between;gap:12px;font-size:13px;font-weight:700}.agentic-diagnostics-panel__badge{padding:2px 6px;border:1px solid rgba(107,114,128,.28);border-radius:8px;font-size:11px;font-weight:600;color:#4b5563}.agentic-diagnostics-panel__description{margin:8px 0 10px;color:#4b5563;font-size:12px;line-height:1.4}.agentic-diagnostics-panel pre{margin:0;white-space:pre-wrap;overflow-wrap:anywhere;font-size:11px;line-height:1.45;color:#1f2937}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.MatMiniFabButton, selector: "button[mat-mini-fab], a[mat-mini-fab], button[matMiniFab], a[matMiniFab]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i3.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }, { kind: "component", type: DynamicWidgetPageComponent, selector: "praxis-dynamic-page", inputs: ["page", "context", "strictValidation", "enableCustomization", "showPageSettingsButton", "shellEditorComponent", "pageEditorComponent", "autoPersist", "pageIdentity", "componentInstanceId"], outputs: ["pageChange", "widgetEvent", "widgetDiagnosticsChange"] }, { kind: "component", type: FloatingToolbarComponent, selector: "praxis-floating-toolbar", inputs: ["visible", "canUndo", "canRedo"], outputs: ["add", "undo", "redo", "settings", "preview", "save"] }, { kind: "component", type: ConnectionsViewerPanelComponent, selector: "praxis-connections-viewer-panel", inputs: ["open", "page"], outputs: ["focusWidget", "openPageSettings"] }, { kind: "component", type: PraxisAiAssistantShellComponent, selector: "praxis-ai-assistant-shell", inputs: ["labels", "mode", "state", "contextItems", "attachments", "messages", "quickReplies", "prompt", "statusText", "errorText", "testIdPrefix", "panelTestId", "submitTestId", "applyTestId", "busy", "canSubmit", "canApply", "submitOnEnter", "enableFileAttachments", "attachmentAccept", "attachmentMultiple", "draggable", "resizable", "minWidth", "minHeight", "margin", "layout"], outputs: ["promptChange", "submitPrompt", "apply", "close", "attach", "attachmentsPasted", "attachmentsSelected", "removeAttachment", "messageAction", "editMessage", "resendMessage", "quickReply", "layoutChange"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DynamicPageBuilderComponent, decorators: [{
             type: Component,
@@ -7219,6 +7863,26 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
         (close)="toggleAgenticAuthoring()"
       />
 
+      <section
+        *ngIf="agenticAuthoringIncludeLlmDiagnostics && agenticAuthoringLlmDiagnosticsText()"
+        class="agentic-diagnostics-panel"
+        data-testid="page-builder-agentic-llm-diagnostics"
+        role="region"
+        [attr.aria-label]="tx('agentic.diagnostics.title', 'LLM diagnostics')"
+        [style.top.px]="agenticAuthoringDiagnosticsTop()"
+      >
+        <header class="agentic-diagnostics-panel__header">
+          <span>{{ tx('agentic.diagnostics.title', 'LLM diagnostics') }}</span>
+          <span class="agentic-diagnostics-panel__badge">
+            {{ tx('agentic.diagnostics.badge', 'Debug') }}
+          </span>
+        </header>
+        <p class="agentic-diagnostics-panel__description">
+          {{ tx('agentic.diagnostics.description', 'Prompt, context bundle, and tool catalog returned by the backend for this turn.') }}
+        </p>
+        <pre>{{ agenticAuthoringLlmDiagnosticsText() }}</pre>
+      </section>
+
       <praxis-floating-toolbar
         [visible]="showSettings()"
         [canUndo]="false"
@@ -7253,7 +7917,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
         </button>
       </praxis-floating-toolbar>
     </div>
-  `, styles: [":host{display:block;position:relative;min-height:var(--pdx-page-builder-min-height, 420px)}.builder-shell{display:block;position:relative;min-height:inherit;height:100%}\n"] }]
+  `, styles: [":host{display:block;position:relative;min-height:var(--pdx-page-builder-min-height, 420px)}.builder-shell{display:block;position:relative;min-height:inherit;height:100%}.agentic-diagnostics-panel{position:absolute;z-index:21;right:16px;width:min(520px,calc(100% - 32px));max-height:min(440px,calc(100% - 32px));overflow:auto;padding:12px;border:1px solid rgba(107,114,128,.28);border-radius:8px;background:#fffffff5;color:#111827;box-shadow:0 14px 36px #0000003d}.agentic-diagnostics-panel__header{display:flex;align-items:center;justify-content:space-between;gap:12px;font-size:13px;font-weight:700}.agentic-diagnostics-panel__badge{padding:2px 6px;border:1px solid rgba(107,114,128,.28);border-radius:8px;font-size:11px;font-weight:600;color:#4b5563}.agentic-diagnostics-panel__description{margin:8px 0 10px;color:#4b5563;font-size:12px;line-height:1.4}.agentic-diagnostics-panel pre{margin:0;white-space:pre-wrap;overflow-wrap:anywhere;font-size:11px;line-height:1.45;color:#1f2937}\n"] }]
         }], ctorParameters: () => [{ type: i1.MatDialog }, { type: undefined, decorators: [{
                     type: Optional
                 }, {
@@ -7294,6 +7958,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                 type: Input
             }], agenticAuthoringEtag: [{
                 type: Input
+            }], agenticAuthoringIncludeLlmDiagnostics: [{
+                type: Input
+            }], agenticAuthoringEnableStreaming: [{
+                type: Input
             }], pageChange: [{
                 type: Output
             }], agenticAuthoringApplied: [{

package/index.d.ts

@@ -7,7 +7,7 @@ import * as rxjs from 'rxjs';
 import { BehaviorSubject, Observable } from 'rxjs';
 import { FormGroup, FormControl, FormArray } from '@angular/forms';
 import { SettingsValueProvider } from '@praxisui/settings-panel';
-import { AgenticAuthoringPlanRequestContract, AgenticAuthoringQuickReplyContract, AgenticAuthoringPendingClarificationContract, AgenticAuthoringAttachmentSummaryContract, AgenticAuthoringIntentResolutionRequestContract, AgenticAuthoringConversationMessageContract, PraxisAssistantShellMessage, PraxisAssistantShellQuickReply, PraxisAssistantShellAttachment, PraxisAssistantShellLayout, PraxisAssistantShellLabels, PraxisAssistantShellState, PraxisAssistantShellContextItem } from '@praxisui/ai';
+import { AgenticAuthoringPlanRequestContract, AgenticAuthoringCandidateContract, AiJsonValue, AgenticAuthoringQuickReplyContract, AgenticAuthoringPendingClarificationContract, AiJsonObject, AgenticAuthoringComponentCapabilitiesResultContract, AgenticAuthoringComponentCapabilityCatalogContract, AgenticAuthoringComponentCapabilityContract, AgenticAuthoringComponentFieldAliasContract, AgenticAuthoringComponentCapabilityExampleContract, AgenticAuthoringAttachmentSummaryContract, AgenticAuthoringIntentResolutionRequestContract, AgenticAuthoringConversationMessageContract, AgenticAuthoringResourceCandidatesRequestContract, AgenticAuthoringResourceCandidatesResultContract, AgenticAuthoringTurnStreamStartResponseContract, AgenticAuthoringTurnStreamEnvelopeContract, PraxisAssistantShellMessage, PraxisAssistantShellQuickReply, PraxisAssistantShellAttachment, PraxisAssistantShellLayout, PraxisAssistantShellLabels, PraxisAssistantShellState, PraxisAssistantShellContextItem } from '@praxisui/ai';
 
 declare const PLACEHOLDER = 1;
 
@@ -545,6 +545,19 @@ interface PageBuilderAgenticAuthoringOptions {
     baseUrl?: string;
     headersFactory?: () => Record<string, string | undefined>;
     defaultHeaders?: Record<string, string>;
+    eventSourceFactory?: PageBuilderAgenticAuthoringEventSourceFactory;
+    streamConnectionErrorGraceMs?: number;
+}
+interface PageBuilderAgenticAuthoringEventSource {
+    onmessage: ((event: MessageEvent<string>) => void) | null;
+    onerror: ((event: Event) => void) | null;
+    addEventListener?(type: string, listener: (event: MessageEvent<string>) => void): void;
+    close(): void;
+}
+type PageBuilderAgenticAuthoringEventSourceFactory = (url: string) => PageBuilderAgenticAuthoringEventSource;
+interface PageBuilderAgenticAuthoringTurnStreamConnectionError {
+    readonly praxisAgenticTurnStreamConnectionError: true;
+    readonly cause: unknown;
 }
 interface PageBuilderAgenticAuthoringPromptRequest extends Omit<AgenticAuthoringPlanRequestContract, 'currentPage' | 'intentResolution'> {
     provider?: PageBuilderAgenticAuthoringProvider | null;
@@ -560,11 +573,29 @@ interface PageBuilderAgenticAuthoringIntentResolutionRequest extends Omit<Agenti
     componentCapabilities?: PageBuilderAgenticAuthoringComponentCapabilitiesResult | null;
     attachmentSummaries?: PageBuilderAgenticAuthoringAttachmentSummary[];
 }
+interface PageBuilderAgenticAuthoringTurnStreamRequest {
+    userPrompt: string;
+    targetApp?: string | null;
+    targetComponentId?: string | null;
+    currentRoute?: string | null;
+    provider?: PageBuilderAgenticAuthoringProvider | null;
+    model?: string | null;
+    apiKey?: string | null;
+    currentPage?: unknown;
+    selectedWidgetKey?: string | null;
+    sessionId?: string | null;
+    clientTurnId?: string | null;
+    conversationMessages?: PageBuilderAgenticAuthoringConversationMessage[];
+    pendingClarification?: PageBuilderAgenticAuthoringPendingClarification | null;
+    componentCapabilities?: PageBuilderAgenticAuthoringComponentCapabilitiesResult | null;
+    attachmentSummaries?: PageBuilderAgenticAuthoringAttachmentSummary[];
+    contextHints?: AiJsonObject | null;
+}
 type PageBuilderAgenticAuthoringConversationMessage = AgenticAuthoringConversationMessageContract;
 type PageBuilderAgenticAuthoringPendingClarification = AgenticAuthoringPendingClarificationContract;
 type PageBuilderAgenticAuthoringQuickReply = AgenticAuthoringQuickReplyContract;
 type PageBuilderAgenticAuthoringAttachmentSummary = AgenticAuthoringAttachmentSummaryContract;
-interface PageBuilderAgenticAuthoringCandidate {
+interface PageBuilderAgenticAuthoringCandidate extends AgenticAuthoringCandidateContract {
     resourcePath: string;
     operation: string;
     schemaUrl: string;
@@ -573,6 +604,17 @@ interface PageBuilderAgenticAuthoringCandidate {
     score: number;
     reason: string;
     evidence: string[];
+    [key: string]: AiJsonValue | undefined;
+}
+interface PageBuilderAgenticAuthoringResourceCandidatesRequest extends AgenticAuthoringResourceCandidatesRequestContract {
+}
+interface PageBuilderAgenticAuthoringResourceCandidatesResult extends Omit<AgenticAuthoringResourceCandidatesResultContract, 'candidates'> {
+    valid: boolean;
+    tool: string;
+    retrievalQuery: string;
+    artifactKind: string;
+    candidates: PageBuilderAgenticAuthoringCandidate[];
+    warnings: string[];
 }
 interface PageBuilderAgenticAuthoringTarget {
     widgetKey: string;
@@ -587,22 +629,28 @@ interface PageBuilderAgenticAuthoringGateResult {
     status: string;
     messages: string[];
 }
-interface PageBuilderAgenticAuthoringComponentFieldAlias {
+interface PageBuilderAgenticAuthoringComponentFieldAlias extends AgenticAuthoringComponentFieldAliasContract {
     field: string;
     aliases: string[];
 }
-interface PageBuilderAgenticAuthoringComponentCapability {
+interface PageBuilderAgenticAuthoringComponentCapability extends Omit<AgenticAuthoringComponentCapabilityContract, 'fieldAliases' | 'examples'> {
     id: string;
     changeKind: string;
     triggerTerms: string[];
     fieldAliases: PageBuilderAgenticAuthoringComponentFieldAlias[];
+    examples?: PageBuilderAgenticAuthoringComponentCapabilityExample[];
+}
+interface PageBuilderAgenticAuthoringComponentCapabilityExample extends AgenticAuthoringComponentCapabilityExampleContract {
+    prompt: string;
+    intent: string;
+    configHints: string[];
 }
-interface PageBuilderAgenticAuthoringComponentCapabilityCatalog {
+interface PageBuilderAgenticAuthoringComponentCapabilityCatalog extends Omit<AgenticAuthoringComponentCapabilityCatalogContract, 'capabilities'> {
     componentId: string;
     version: string;
     capabilities: PageBuilderAgenticAuthoringComponentCapability[];
 }
-interface PageBuilderAgenticAuthoringComponentCapabilitiesResult {
+interface PageBuilderAgenticAuthoringComponentCapabilitiesResult extends Omit<AgenticAuthoringComponentCapabilitiesResultContract, 'catalogs'> {
     version: string;
     catalogs: PageBuilderAgenticAuthoringComponentCapabilityCatalog[];
 }
@@ -626,6 +674,7 @@ interface PageBuilderAgenticAuthoringIntentResolutionResult {
     warnings: string[];
     failureCodes: string[];
     currentPageSummary: unknown;
+    llmDiagnostics?: AiJsonObject | null;
 }
 interface PageBuilderMinimalFormPlanResult {
     valid: boolean;
@@ -658,6 +707,8 @@ interface PageBuilderPreviewResult {
     compiledFormPatch: PageBuilderCompiledFormPatch;
     diagnostics?: PageBuilderPreviewDiagnostics | null;
 }
+type PageBuilderAgenticAuthoringTurnStreamStartResponse = AgenticAuthoringTurnStreamStartResponseContract;
+type PageBuilderAgenticAuthoringTurnStreamEvent = AgenticAuthoringTurnStreamEnvelopeContract;
 interface PageBuilderApplyRequest {
     compiledFormPatch: PageBuilderCompiledFormPatch;
     componentId: string;
@@ -687,8 +738,14 @@ declare class PageBuilderAgenticAuthoringService {
     getComponentCapabilities(): Observable<PageBuilderAgenticAuthoringComponentCapabilitiesResult>;
     previewPage(request: PageBuilderAgenticAuthoringPromptRequest): Observable<PageBuilderPreviewResult>;
     resolveIntent(request: PageBuilderAgenticAuthoringIntentResolutionRequest): Observable<PageBuilderAgenticAuthoringIntentResolutionResult>;
+    searchResourceCandidates(request: PageBuilderAgenticAuthoringResourceCandidatesRequest): Observable<PageBuilderAgenticAuthoringResourceCandidatesResult>;
+    streamTurn(request: PageBuilderAgenticAuthoringTurnStreamRequest): Observable<PageBuilderAgenticAuthoringTurnStreamEvent>;
     applyPage(request: PageBuilderApplyRequest): Observable<PageBuilderApplyResult>;
     private buildHeaders;
+    private connectTurnStream;
+    private streamConnectionError;
+    private buildStreamUrl;
+    private createEventSource;
     private formatEtag;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageBuilderAgenticAuthoringService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageBuilderAgenticAuthoringService>;
@@ -779,6 +836,8 @@ declare class DynamicPageBuilderComponent implements OnChanges {
     agenticAuthoringComponentId?: string;
     agenticAuthoringScope: 'user' | 'tenant';
     agenticAuthoringEtag?: string;
+    agenticAuthoringIncludeLlmDiagnostics: boolean;
+    agenticAuthoringEnableStreaming: boolean;
     pageChange: EventEmitter<WidgetPageDefinition>;
     agenticAuthoringApplied: EventEmitter<PageBuilderApplyResult>;
     readonly currentPage: _angular_core.WritableSignal<WidgetPageDefinition>;
@@ -793,6 +852,7 @@ declare class DynamicPageBuilderComponent implements OnChanges {
     readonly agenticAuthoringConversation: _angular_core.WritableSignal<PraxisAssistantShellMessage[]>;
     readonly agenticAuthoringQuickReplies: _angular_core.WritableSignal<AgenticAuthoringQuickReply[]>;
     readonly agenticAuthoringAttachments: _angular_core.WritableSignal<PraxisAssistantShellAttachment[]>;
+    readonly agenticAuthoringLlmDiagnostics: _angular_core.WritableSignal<Record<string, unknown> | null>;
     readonly agenticAuthoringEditingMessageId: _angular_core.WritableSignal<string | null>;
     readonly agenticAuthoringPanelLayout: _angular_core.WritableSignal<PraxisAssistantShellLayout>;
     private previewMode;
@@ -827,6 +887,11 @@ declare class DynamicPageBuilderComponent implements OnChanges {
     private ensureAgenticTurnController;
     private applyAgenticPreviewLocally;
     private applyAgenticTurnState;
+    private consumeAgenticTurn;
+    agenticAuthoringDiagnosticsTop(): number;
+    agenticAuthoringLlmDiagnosticsText(): string;
+    private resolveAgenticLlmDiagnostics;
+    private toRecord;
     private resolvePreviewCompiledFormPatch;
     focusCanvasWidget(widgetKey: string): void;
     private parsePage;
@@ -842,8 +907,8 @@ declare class DynamicPageBuilderComponent implements OnChanges {
     private cloneValue;
     tx(key: string, fallback: string): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicPageBuilderComponent, [null, { optional: true; }]>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicPageBuilderComponent, "praxis-dynamic-page-builder", never, { "page": { "alias": "page"; "required": false; }; "context": { "alias": "context"; "required": false; }; "strictValidation": { "alias": "strictValidation"; "required": false; }; "autoPersist": { "alias": "autoPersist"; "required": false; }; "enableCustomization": { "alias": "enableCustomization"; "required": false; }; "showSettingsButton": { "alias": "showSettingsButton"; "required": false; }; "pageIdentity": { "alias": "pageIdentity"; "required": false; }; "componentInstanceId": { "alias": "componentInstanceId"; "required": false; }; "pageEditorComponent": { "alias": "pageEditorComponent"; "required": false; }; "enableAgenticAuthoring": { "alias": "enableAgenticAuthoring"; "required": false; }; "agenticAuthoringProvider": { "alias": "agenticAuthoringProvider"; "required": false; }; "agenticAuthoringModel": { "alias": "agenticAuthoringModel"; "required": false; }; "agenticAuthoringApiKey": { "alias": "agenticAuthoringApiKey"; "required": false; }; "agenticAuthoringComponentId": { "alias": "agenticAuthoringComponentId"; "required": false; }; "agenticAuthoringScope": { "alias": "agenticAuthoringScope"; "required": false; }; "agenticAuthoringEtag": { "alias": "agenticAuthoringEtag"; "required": false; }; }, { "pageChange": "pageChange"; "agenticAuthoringApplied": "agenticAuthoringApplied"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicPageBuilderComponent, "praxis-dynamic-page-builder", never, { "page": { "alias": "page"; "required": false; }; "context": { "alias": "context"; "required": false; }; "strictValidation": { "alias": "strictValidation"; "required": false; }; "autoPersist": { "alias": "autoPersist"; "required": false; }; "enableCustomization": { "alias": "enableCustomization"; "required": false; }; "showSettingsButton": { "alias": "showSettingsButton"; "required": false; }; "pageIdentity": { "alias": "pageIdentity"; "required": false; }; "componentInstanceId": { "alias": "componentInstanceId"; "required": false; }; "pageEditorComponent": { "alias": "pageEditorComponent"; "required": false; }; "enableAgenticAuthoring": { "alias": "enableAgenticAuthoring"; "required": false; }; "agenticAuthoringProvider": { "alias": "agenticAuthoringProvider"; "required": false; }; "agenticAuthoringModel": { "alias": "agenticAuthoringModel"; "required": false; }; "agenticAuthoringApiKey": { "alias": "agenticAuthoringApiKey"; "required": false; }; "agenticAuthoringComponentId": { "alias": "agenticAuthoringComponentId"; "required": false; }; "agenticAuthoringScope": { "alias": "agenticAuthoringScope"; "required": false; }; "agenticAuthoringEtag": { "alias": "agenticAuthoringEtag"; "required": false; }; "agenticAuthoringIncludeLlmDiagnostics": { "alias": "agenticAuthoringIncludeLlmDiagnostics"; "required": false; }; "agenticAuthoringEnableStreaming": { "alias": "agenticAuthoringEnableStreaming"; "required": false; }; }, { "pageChange": "pageChange"; "agenticAuthoringApplied": "agenticAuthoringApplied"; }, never, never, true, never>;
 }
 
 export { ComponentPaletteDialogComponent, ConfirmDialogComponent, DynamicPageBuilderComponent, DynamicPageConfigEditorComponent, FloatingToolbarComponent, PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS, PAGE_BUILDER_AI_CAPABILITIES, PAGE_BUILDER_WIDGET_AI_CATALOGS, PLACEHOLDER, PageBuilderAgenticAuthoringService, PageConfigEditorComponent, TileToolbarComponent, WidgetShellEditorComponent, clearWidgetAiCatalogs, getPageAiCatalog, getWidgetAiCapabilities, providePageBuilderWidgetAiCatalogs, registerWidgetAiCatalog, registerWidgetAiCatalogs };
-export type { Capability, CapabilityCatalog, CapabilityCategory, ComponentPaletteData, ConfirmDialogData, PageBuilderAgenticAuthoringAttachmentSummary, PageBuilderAgenticAuthoringCandidate, PageBuilderAgenticAuthoringComponentCapabilitiesResult, PageBuilderAgenticAuthoringComponentCapability, PageBuilderAgenticAuthoringComponentCapabilityCatalog, PageBuilderAgenticAuthoringComponentFieldAlias, PageBuilderAgenticAuthoringConversationMessage, PageBuilderAgenticAuthoringGateResult, PageBuilderAgenticAuthoringIntentResolutionRequest, PageBuilderAgenticAuthoringIntentResolutionResult, PageBuilderAgenticAuthoringOptions, PageBuilderAgenticAuthoringPendingClarification, PageBuilderAgenticAuthoringPromptRequest, PageBuilderAgenticAuthoringProvider, PageBuilderAgenticAuthoringQuickReply, PageBuilderAgenticAuthoringTarget, PageBuilderApplyRequest, PageBuilderApplyResult, PageBuilderCompiledFormPatch, PageBuilderMinimalFormPlanResult, PageBuilderPreviewDiagnostics, PageBuilderPreviewResult, ValueKind };
+export type { Capability, CapabilityCatalog, CapabilityCategory, ComponentPaletteData, ConfirmDialogData, PageBuilderAgenticAuthoringAttachmentSummary, PageBuilderAgenticAuthoringCandidate, PageBuilderAgenticAuthoringComponentCapabilitiesResult, PageBuilderAgenticAuthoringComponentCapability, PageBuilderAgenticAuthoringComponentCapabilityCatalog, PageBuilderAgenticAuthoringComponentCapabilityExample, PageBuilderAgenticAuthoringComponentFieldAlias, PageBuilderAgenticAuthoringConversationMessage, PageBuilderAgenticAuthoringEventSource, PageBuilderAgenticAuthoringEventSourceFactory, PageBuilderAgenticAuthoringGateResult, PageBuilderAgenticAuthoringIntentResolutionRequest, PageBuilderAgenticAuthoringIntentResolutionResult, PageBuilderAgenticAuthoringOptions, PageBuilderAgenticAuthoringPendingClarification, PageBuilderAgenticAuthoringPromptRequest, PageBuilderAgenticAuthoringProvider, PageBuilderAgenticAuthoringQuickReply, PageBuilderAgenticAuthoringResourceCandidatesRequest, PageBuilderAgenticAuthoringResourceCandidatesResult, PageBuilderAgenticAuthoringTarget, PageBuilderAgenticAuthoringTurnStreamConnectionError, PageBuilderAgenticAuthoringTurnStreamEvent, PageBuilderAgenticAuthoringTurnStreamRequest, PageBuilderAgenticAuthoringTurnStreamStartResponse, PageBuilderApplyRequest, PageBuilderApplyResult, PageBuilderCompiledFormPatch, PageBuilderMinimalFormPlanResult, PageBuilderPreviewDiagnostics, PageBuilderPreviewResult, ValueKind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisui/page-builder",
-  "version": "8.0.0-beta.8",
+  "version": "8.0.0-beta.9",
   "description": "Page and widget builder utilities for Praxis UI (grid, dynamic widgets, editors).",
   "peerDependencies": {
     "@angular/common": "^20.0.0",
@@ -8,9 +8,9 @@
     "@angular/forms": "^20.0.0",
     "@angular/cdk": "^20.0.0",
     "@angular/material": "^20.0.0",
-    "@praxisui/ai": "^8.0.0-beta.8",
-    "@praxisui/core": "^8.0.0-beta.8",
-    "@praxisui/settings-panel": "^8.0.0-beta.8"
+    "@praxisui/ai": "^8.0.0-beta.9",
+    "@praxisui/core": "^8.0.0-beta.9",
+    "@praxisui/settings-panel": "^8.0.0-beta.9"
   },
   "dependencies": {
     "tslib": "^2.3.0"