@praxisui/manual-form 8.0.0-beta.20 → 8.0.0-beta.22

package/README.md

@@ -497,7 +497,10 @@ Apache-2.0 — consulte `LICENSE` neste pacote ou no repositório raiz.
 
 ## Notas adicionais
 
-- Quando `enableCustomization` estiver ativo, o container renderiza o assistente AI (Praxis AI) no header do formulario.
+- Quando `enableCustomization` estiver ativo, o container abre o shell compartilhado `PraxisAiAssistantShellComponent` e registra sessao global minimizavel em vez de embutir o assistente legado.
+- O contexto do assistente e seguro e semantico: identidade do formulario, `formId`, contagem de campos/secoes/acoes, nomes de campos, referencia ao `PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST` e hints de governanca.
+- Prompts de regra, politica, compliance, publicacao, materializacao ou enforcement seguem para handoff governado `domain-rules/intake` e nao sao aplicados como patch local do formulario.
+- Patches JSON livres vindos do backend sao rejeitados. O apply local permanece bloqueado ate existir `componentEditPlan` compilado e validado pelo manifesto canonico.
 - `componentInstanceId` ajuda a compor a chave de persistencia (com `formId` e `persistenceOptions`), evitando conflito entre instancias da mesma tela.
 
 ## Comparativo — Manual vs Dinâmico (JSON)

package/fesm2022/praxisui-manual-form.mjs

@@ -1,11 +1,11 @@
 import { ensureIds, DynamicFormService, ASYNC_CONFIG_STORAGE, RULE_PROPERTY_SCHEMA, deepMerge, resolveControlTypeAlias, FieldControlType, normalizeControlTypeKey, FormHooksRegistry, ComponentKeyService, FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS, DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP, FieldSelectorRegistry, providePraxisI18n, PraxisI18nService, API_URL } from '@praxisui/core';
 import * as i0 from '@angular/core';
 import { inject, Optional, Inject, Injectable, input, output, ChangeDetectionStrategy, Component, Input, InjectionToken, isDevMode, EventEmitter, HostListener, ViewChild, Output, ChangeDetectorRef, DestroyRef, PLATFORM_ID, effect, ContentChildren, signal, computed, Directive } from '@angular/core';
-import { BehaviorSubject, debounceTime, fromEvent, of } from 'rxjs';
+import { BehaviorSubject, firstValueFrom, debounceTime, fromEvent, of } from 'rxjs';
 import { take } from 'rxjs/operators';
 import { CommonModule, isPlatformBrowser } from '@angular/common';
 import { ActivatedRoute } from '@angular/router';
-import { BaseAiAdapter, PraxisAiAssistantComponent } from '@praxisui/ai';
+import { BaseAiAdapter, AiBackendApiService, PraxisAssistantSessionRegistryService, PraxisAssistantTurnOrchestratorService, createPraxisAssistantViewportLayout, PraxisAiAssistantShellComponent } from '@praxisui/ai';
 import * as i1 from '@angular/forms';
 import { FormGroupDirective, FormGroup, FormControl, Validators, ReactiveFormsModule, FormControlName, ControlContainer, FormsModule } from '@angular/forms';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
@@ -1083,6 +1083,8 @@ const MANUAL_FORM_AI_CAPABILITIES = {
 class ManualFormAiAdapter extends BaseAiAdapter {
     host;
     componentName = 'Manual Form';
+    componentId = 'praxis-manual-form';
+    componentType = 'form';
     constructor(host) {
         super();
         this.host = host;
@@ -1105,6 +1107,48 @@ class ManualFormAiAdapter extends BaseAiAdapter {
             dirty: form?.dirty ?? false,
         };
     }
+    getDataProfile() {
+        const config = this.host.instance?.currentConfig;
+        return {
+            formId: this.safeFormId(),
+            sectionCount: config?.sections?.length ?? 0,
+            fieldCount: config?.fieldMetadata?.length ?? 0,
+            actionCount: [
+                config?.actions?.submit,
+                config?.actions?.cancel,
+                config?.actions?.reset,
+                ...(config?.actions?.custom ?? []),
+            ].filter(Boolean).length,
+            hasPersistence: !!this.host.persistenceOptions(),
+            autoSave: !!this.host.enableAutoSave(),
+        };
+    }
+    getSchemaFields() {
+        return (this.host.instance?.currentConfig?.fieldMetadata ?? [])
+            .map((field) => ({
+            name: field.name,
+            label: field.label,
+            type: field.type,
+            required: !!(field.required || field.validators?.required),
+            readonly: !!field.readonly,
+            hidden: !!field.hidden,
+        }))
+            .filter((field) => typeof field.name === 'string' && !!field.name.trim());
+    }
+    getAuthoringContext() {
+        return {
+            authoringManifestRef: 'PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST',
+            runtimeAuthoringPolicy: {
+                mode: 'agentic-authoring',
+                enableCustomization: !!this.host.enableCustomization(),
+                canApplyLocalPatch: false,
+                reason: 'praxis-manual-form ainda exige componentEditPlan manifest-backed antes de aplicar patch local pelo copiloto.',
+            },
+            domainCatalog: {
+                recommendedAuthoringFlow: 'component_authoring',
+            },
+        };
+    }
     createSnapshot() {
         return this.getCurrentConfig();
     }
@@ -1178,6 +1222,338 @@ class ManualFormAiAdapter extends BaseAiAdapter {
     }
 }
 
+class ManualFormAgenticAuthoringTurnFlow {
+    adapter;
+    aiApi;
+    mode = 'agentic-authoring';
+    constructor(adapter, aiApi) {
+        this.adapter = adapter;
+        this.aiApi = aiApi;
+    }
+    async submit(request) {
+        const prompt = (request.prompt ?? '').trim();
+        if (!prompt) {
+            return {
+                state: 'listening',
+                phase: 'capture',
+                statusText: '',
+            };
+        }
+        const componentId = this.adapter.componentId || request.componentId || 'praxis-manual-form';
+        const componentType = this.adapter.componentType || request.componentType || 'form';
+        const currentState = this.toAiJsonObject(this.adapter.getCurrentConfig());
+        const dataProfile = this.optionalJsonObject(this.adapter.getDataProfile?.());
+        const runtimeState = this.optionalJsonObject(this.adapter.getRuntimeState?.());
+        const schemaFields = this.adapter.getSchemaFields?.()
+            ?.map((field) => this.toAiJsonObject(field))
+            .filter((field) => Object.keys(field).length > 0);
+        const contextHints = this.optionalJsonObject(this.adapter.getAuthoringContext?.());
+        if (this.shouldRouteToGovernedDecision(prompt, contextHints)) {
+            return this.toGovernedDecisionHandoff(prompt, request);
+        }
+        const response = await firstValueFrom(this.aiApi.getPatch({
+            componentId,
+            componentType,
+            userPrompt: prompt,
+            sessionId: request.sessionId,
+            clientTurnId: request.clientTurnId,
+            messages: this.toChatMessages(request.messages, prompt),
+            currentState,
+            currentStateDigest: this.buildCurrentStateDigest(dataProfile),
+            uiContextRef: {
+                componentId,
+                componentType,
+            },
+            ...(dataProfile ? { dataProfile } : {}),
+            ...(runtimeState ? { runtimeState } : {}),
+            ...(schemaFields?.length ? { schemaFields } : {}),
+            ...(contextHints ? { contextHints } : {}),
+        }));
+        return this.toTurnResult(this.compileAdapterResponse(response), request);
+    }
+    async apply(_request) {
+        return {
+            state: 'error',
+            phase: 'apply',
+            assistantMessage: 'O formulario manual ainda exige componentEditPlan validado pelo manifesto antes de aplicar mudancas locais.',
+            errorText: 'Aplicacao local bloqueada ate existir compilacao manifest-backed para praxis-manual-form.',
+            canApply: false,
+            pendingPatch: null,
+        };
+    }
+    cancel() {
+        return Promise.resolve({
+            state: 'listening',
+            phase: 'capture',
+            assistantMessage: 'Solicitacao cancelada.',
+            statusText: '',
+            canApply: false,
+            pendingPatch: null,
+            pendingClarification: null,
+        });
+    }
+    retry(request) {
+        const lastPrompt = [...(request.messages ?? [])].reverse()
+            .find((message) => message.role === 'user')?.text;
+        return this.submit({
+            ...request,
+            prompt: lastPrompt ?? request.prompt,
+            action: { kind: 'retry' },
+        });
+    }
+    toTurnResult(response, request) {
+        if (!response) {
+            return {
+                state: 'error',
+                phase: 'capture',
+                assistantMessage: 'Resposta vazia da IA.',
+                errorText: 'Resposta vazia da IA.',
+            };
+        }
+        if (response.type === 'clarification') {
+            return {
+                state: 'clarification',
+                phase: 'clarify',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: response.message || 'Preciso de mais detalhes para continuar.',
+                clarificationQuestions: this.toClarificationQuestions(response),
+                quickReplies: this.toQuickReplies(response),
+                canApply: false,
+            };
+        }
+        if (response.type === 'info') {
+            const message = response.message || response.explanation || 'Informacao gerada.';
+            return {
+                state: 'success',
+                phase: 'summarize',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: message,
+                statusText: message,
+                canApply: false,
+            };
+        }
+        if (response.type === 'error') {
+            const message = response.message || 'Falha ao gerar alteracao de formulario manual.';
+            return {
+                state: 'error',
+                phase: 'capture',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: message,
+                errorText: message,
+                diagnostics: response.warnings?.length ? { warnings: response.warnings } : undefined,
+            };
+        }
+        if (response.patch && Object.keys(response.patch).length > 0) {
+            return {
+                state: 'error',
+                phase: 'review',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: 'O formulario manual rejeitou patch livre. Gere um componentEditPlan validado pelo PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST antes de propor alteracao local.',
+                errorText: 'Patch livre de formulario manual rejeitado.',
+                canApply: false,
+                pendingPatch: null,
+                diagnostics: {
+                    warnings: [
+                        'free-manual-form-patch-rejected',
+                        'Use componentEditPlan validado contra PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST.',
+                    ],
+                },
+            };
+        }
+        return {
+            state: 'success',
+            phase: 'summarize',
+            sessionId: response.sessionId ?? request.sessionId,
+            assistantMessage: response.message || response.explanation || 'Nenhuma alteracao necessaria.',
+            statusText: response.message || response.explanation || 'Nenhuma alteracao necessaria.',
+            canApply: false,
+        };
+    }
+    compileAdapterResponse(response) {
+        const compiled = this.adapter.compileAiResponse?.(response);
+        if (!compiled) {
+            return response;
+        }
+        if (compiled.type === 'error') {
+            return {
+                type: 'error',
+                message: compiled.message || 'O componentEditPlan do formulario manual nao passou na validacao de capacidades.',
+                warnings: compiled.warnings,
+            };
+        }
+        const warnings = [
+            ...(response.warnings ?? []),
+            ...(compiled.warnings ?? []),
+        ];
+        return {
+            ...response,
+            ...compiled,
+            patch: compiled.patch,
+            warnings: warnings.length ? warnings : undefined,
+        };
+    }
+    toChatMessages(messages, prompt) {
+        const supported = (messages ?? [])
+            .filter((message) => message.role === 'user' || message.role === 'assistant' || message.role === 'system')
+            .map((message) => ({
+            role: message.role,
+            content: message.text,
+        }))
+            .filter((message) => message.content.trim().length > 0);
+        return supported.length ? supported : [{ role: 'user', content: prompt }];
+    }
+    toClarificationQuestions(response) {
+        const labels = response.questions?.length
+            ? response.questions
+            : response.message
+                ? [response.message]
+                : ['Qual ajuste voce quer aplicar no formulario manual?'];
+        const options = this.toQuickReplies(response).map((reply) => ({
+            id: reply.id,
+            label: reply.label,
+            value: reply.prompt,
+        }));
+        return labels.map((label, index) => ({
+            id: `manual-form-clarification-${index + 1}`,
+            type: options.length ? 'single-choice' : 'text',
+            label,
+            allowCustom: true,
+            options,
+        }));
+    }
+    toQuickReplies(response) {
+        const payloads = response.optionPayloads ?? [];
+        if (payloads.length) {
+            return payloads
+                .map((option, index) => {
+                const label = option.label?.trim() || option.value?.trim() || `Opcao ${index + 1}`;
+                const prompt = option.example?.trim() || option.value?.trim() || label;
+                return {
+                    id: `option-${index + 1}`,
+                    label,
+                    prompt,
+                    kind: 'clarification-option',
+                };
+            });
+        }
+        return (response.options ?? [])
+            .filter((option) => !!option?.trim())
+            .map((option, index) => ({
+            id: `option-${index + 1}`,
+            label: option.trim(),
+            prompt: option.trim(),
+            kind: 'clarification-option',
+        }));
+    }
+    buildCurrentStateDigest(dataProfile) {
+        const fieldCount = typeof dataProfile?.['fieldCount'] === 'number' ? dataProfile['fieldCount'] : undefined;
+        return fieldCount !== undefined ? { rowCount: fieldCount } : {};
+    }
+    shouldRouteToGovernedDecision(prompt, contextHints) {
+        const normalized = prompt.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+        const recommendedFlow = this.toRecord(contextHints?.['domainCatalog'])?.['recommendedAuthoringFlow'];
+        if (recommendedFlow === 'shared_rule_authoring')
+            return true;
+        return [
+            'regra',
+            'politica',
+            'policy',
+            'compliance',
+            'lgpd',
+            'privacidade',
+            'aprovacao',
+            'aprovar',
+            'publicar',
+            'materializar',
+            'enforcement',
+            'validacao de negocio',
+            'validar negocio',
+            'elegibilidade',
+            'permissao',
+            'acesso',
+        ].some((term) => normalized.includes(term));
+    }
+    toGovernedDecisionHandoff(prompt, request) {
+        const message = 'Esse pedido parece alterar uma decisao de negocio compartilhada. O formulario manual pode localizar campos e experiencia afetada, mas a regra deve seguir pelo fluxo governado de domain-rules antes de qualquer materializacao runtime.';
+        return {
+            state: 'clarification',
+            phase: 'clarify',
+            sessionId: request.sessionId,
+            assistantMessage: message,
+            statusText: 'Handoff governado necessario.',
+            canApply: false,
+            quickReplies: [
+                {
+                    id: 'shared-rule-handoff',
+                    label: 'Continuar como regra governada',
+                    prompt,
+                    kind: 'shared-rule-handoff',
+                    description: 'Criar intake de domain-rules em vez de aplicar patch local no formulario.',
+                    icon: 'rule',
+                    tone: 'warning',
+                    contextHints: {
+                        flowId: 'shared_rule_authoring',
+                        source: 'praxis-manual-form',
+                        recommendedAction: 'domain-rules/intake',
+                    },
+                },
+            ],
+            clarificationQuestions: [
+                {
+                    id: 'manual-form-governed-rule-confirmation',
+                    type: 'confirm',
+                    label: 'Deseja continuar pelo fluxo governado de regras compartilhadas?',
+                    description: 'Esse caminho permite intake, simulacao, aprovacao/publicacao, materializacao e validacao de enforcement.',
+                    required: true,
+                    options: [
+                        {
+                            id: 'shared-rule-handoff',
+                            label: 'Sim, continuar governado',
+                            value: prompt,
+                            description: 'Nao aplicar como patch local do formulario.',
+                            contextHints: {
+                                flowId: 'shared_rule_authoring',
+                                source: 'praxis-manual-form',
+                            },
+                        },
+                    ],
+                },
+            ],
+            diagnostics: {
+                governedDecisionHandoff: {
+                    flowId: 'shared_rule_authoring',
+                    sourcePrompt: prompt,
+                    sourceComponent: 'praxis-manual-form',
+                },
+            },
+        };
+    }
+    optionalJsonObject(value) {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        const object = this.toAiJsonObject(value);
+        return Object.keys(object).length ? object : undefined;
+    }
+    toAiJsonObject(value) {
+        const record = this.toRecord(value);
+        if (!record) {
+            return {};
+        }
+        try {
+            return JSON.parse(JSON.stringify(record));
+        }
+        catch {
+            return {};
+        }
+    }
+    toRecord(value) {
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : null;
+    }
+}
+
 const MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE = new InjectionToken('MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE');
 const MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE = new InjectionToken('MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE');
 
@@ -1629,6 +2005,17 @@ class ManualFormComponent {
     catch {
         return undefined;
     } })();
+    aiApi = inject(AiBackendApiService);
+    assistantSessions = inject(PraxisAssistantSessionRegistryService);
+    aiTurnOrchestrator = inject(PraxisAssistantTurnOrchestratorService);
+    aiAssistantSessionEffect = effect(() => {
+        const session = this.assistantSessions.activeSession();
+        if (!session || session.id !== this.resolveAiAssistantSessionId())
+            return;
+        if (!this.aiAssistantOpen) {
+            this.openAiAssistantFromSession(session);
+        }
+    }, ...(ngDevMode ? [{ debugName: "aiAssistantSessionEffect" }] : []));
     warnedMissingId = false;
     disableSelectorDefaults = inject(FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS, { optional: true }) ?? false;
     selectorToControlType = inject(MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE, { optional: true }) ??
@@ -1669,6 +2056,21 @@ class ManualFormComponent {
     instance;
     resolvedActions;
     aiAdapter = new ManualFormAiAdapter(this);
+    aiAssistantOpen = false;
+    aiAssistantPrompt = '';
+    aiAssistantViewState = null;
+    aiAssistantLayout = createPraxisAssistantViewportLayout();
+    aiAssistantLabels = {
+        title: 'Copiloto semantico Praxis',
+        subtitle: 'Converse, revise e governe ajustes do formulario manual.',
+        prompt: 'Mensagem',
+        promptPlaceholder: 'Descreva o ajuste que voce precisa no formulario.',
+        emptyConversation: 'Diga o que voce quer alterar no formulario.',
+        submit: 'Interpretar pedido',
+        apply: 'Aplicar ajuste',
+    };
+    aiAssistantController = null;
+    aiAssistantStateSubscription = null;
     formGroup = new FormGroup({});
     registeredDirectives = [];
     constructor() {
@@ -1720,6 +2122,8 @@ class ManualFormComponent {
         this.metadataSubscription?.unsubscribe();
         this.toolbarOverlayRef?.dispose();
         this.outsideClickSubscription?.unsubscribe();
+        this.assistantSessions.removeContextSession(this.buildAiAssistantContextSnapshot().identity);
+        this.aiAssistantStateSubscription?.unsubscribe();
     }
     // =============================
     // ControlContainer interface
@@ -1945,6 +2349,308 @@ class ManualFormComponent {
         this.metadataChange.emit(this.instance.currentConfig);
         this.cdr.markForCheck();
     }
+    openAiAssistant() {
+        this.initializeAiAssistantController();
+        this.aiAssistantOpen = true;
+        this.aiAssistantController?.setContextItems(this.buildAiAssistantContextItems());
+        this.syncAiAssistantSession('active');
+        this.cdr.markForCheck();
+    }
+    openAiAssistantFromSession(session) {
+        if (session.id !== this.resolveAiAssistantSessionId())
+            return;
+        this.initializeAiAssistantController();
+        this.aiAssistantOpen = true;
+        this.aiAssistantController?.setContextItems(this.buildAiAssistantContextItems());
+        this.syncAiAssistantSession('active');
+        this.cdr.markForCheck();
+    }
+    closeAiAssistant() {
+        this.aiAssistantOpen = false;
+        this.syncAiAssistantSession('minimized');
+        this.cdr.markForCheck();
+    }
+    onAiAssistantPromptChange(prompt) {
+        this.aiAssistantPrompt = prompt;
+        this.syncAiAssistantSession();
+    }
+    onAiAssistantSubmit(prompt) {
+        this.aiAssistantController?.submitPrompt(prompt).subscribe((state) => {
+            this.aiAssistantPrompt = '';
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantApply() {
+        this.aiAssistantController?.apply().subscribe((state) => {
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantRetry() {
+        this.aiAssistantController?.retry().subscribe((state) => {
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantCancel() {
+        this.aiAssistantController?.cancel().subscribe((state) => {
+            this.aiAssistantPrompt = '';
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantQuickReply(reply) {
+        const controller = this.aiAssistantController;
+        if (!controller)
+            return;
+        const state = controller.snapshot();
+        const next$ = state.state === 'clarification'
+            ? controller.answerClarification(reply.prompt)
+            : controller.submitPrompt(reply.prompt, {
+                kind: reply.kind || 'quick-reply',
+                id: reply.id,
+                value: reply.prompt,
+            });
+        next$.subscribe((nextState) => {
+            this.aiAssistantPrompt = '';
+            this.aiAssistantViewState = nextState;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantEditMessage(message) {
+        this.aiAssistantPrompt = message.text;
+        this.cdr.markForCheck();
+    }
+    onAiAssistantResendMessage(message) {
+        this.aiAssistantController?.resendMessage(message.id).subscribe((state) => {
+            this.aiAssistantPrompt = '';
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantLayoutChange(layout) {
+        this.aiAssistantLayout = layout;
+    }
+    initializeAiAssistantController() {
+        if (this.aiAssistantController)
+            return;
+        const flow = new ManualFormAgenticAuthoringTurnFlow(this.aiAdapter, this.aiApi);
+        const controller = this.aiTurnOrchestrator.createController(flow, {
+            componentId: this.aiAdapter.componentId || 'praxis-manual-form',
+            componentType: this.aiAdapter.componentType || 'form',
+            contextItems: this.buildAiAssistantContextItems(),
+        });
+        this.aiAssistantController = controller;
+        this.aiAssistantViewState = controller.snapshot();
+        this.aiAssistantStateSubscription?.unsubscribe();
+        this.aiAssistantStateSubscription = controller.state$.subscribe((state) => {
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+        this.cdr.markForCheck();
+    }
+    buildAiAssistantContextItems() {
+        const items = [
+            {
+                id: 'component',
+                label: 'Componente',
+                value: 'Formulario manual',
+                kind: 'component',
+                icon: 'edit_note',
+            },
+            {
+                id: 'form-id',
+                label: 'Formulario',
+                value: this.safeAiAssistantFormId(),
+                kind: 'custom',
+                icon: 'tag',
+            },
+        ];
+        const fieldsCount = this.instance?.currentConfig?.fieldMetadata?.length ?? 0;
+        if (fieldsCount > 0) {
+            items.push({
+                id: 'fields',
+                label: 'Campos',
+                value: String(fieldsCount),
+                kind: 'custom',
+                icon: 'view_list',
+            });
+        }
+        return items;
+    }
+    buildAiAssistantContextSnapshot() {
+        const fieldNames = this.collectAiAssistantFieldNames();
+        const counts = this.collectAiAssistantCounts();
+        return {
+            identity: {
+                sessionId: this.resolveAiAssistantSessionId(),
+                ownerId: this.resolveAiAssistantOwnerId(),
+                ownerType: 'manual-form',
+                componentId: 'praxis-manual-form',
+                componentType: 'form',
+                routeKey: this.resolveAiAssistantRouteKey(),
+            },
+            target: {
+                kind: 'component',
+                id: this.resolveAiAssistantOwnerId(),
+                label: this.formTitle() || this.safeAiAssistantFormId(),
+                metadata: {
+                    formId: this.safeAiAssistantFormId(),
+                    hasCustomization: !!this.enableCustomization(),
+                },
+            },
+            contextItems: this.buildAiAssistantContextItems().map((item) => ({
+                id: item.id,
+                label: item.label,
+                value: item.value || '',
+                kind: item.kind,
+            })),
+            mode: 'agentic-authoring',
+            authoringManifestRef: {
+                componentId: 'praxis-manual-form',
+                source: 'PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST',
+            },
+            schemaFields: fieldNames.length ? fieldNames : undefined,
+            dataProfileDigest: {
+                summary: `${counts.fieldCount} campo(s), ${counts.sectionCount} secao(oes), ${counts.actionCount} acao(oes)`,
+                counts,
+            },
+            runtimeStateDigest: {
+                summary: this.instance
+                    ? `Formulario ${this.formGroup.valid ? 'valido' : 'invalido'} e ${this.formGroup.dirty ? 'alterado' : 'sem alteracoes'}`
+                    : 'Formulario ainda sem instancia runtime.',
+                fields: [
+                    'currentConfig',
+                    'fieldMetadata',
+                    'form',
+                    'metadataChange',
+                ],
+            },
+            capabilityRefs: [
+                {
+                    id: 'manual-form.component-edit-plan',
+                    label: 'Plano de edicao de formulario manual',
+                    source: 'PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST',
+                    risk: 'medium',
+                },
+            ],
+            governanceHints: [
+                {
+                    kind: 'business-rule-boundary',
+                    label: 'Regras compartilhadas exigem governanca',
+                    reason: 'Politicas, validacoes reutilizaveis e compliance nao devem ser aplicados como patch local do formulario.',
+                    risk: 'high',
+                },
+            ],
+        };
+    }
+    syncAiAssistantSession(visibility = null) {
+        if (!this.enableCustomization())
+            return;
+        if (!this.aiAssistantOpen && !this.hasAiAssistantSessionState() && visibility !== 'minimized')
+            return;
+        const state = this.aiAssistantViewState;
+        this.assistantSessions.upsertContextSession(this.buildAiAssistantContextSnapshot(), {
+            title: 'Copiloto semantico Praxis',
+            summary: this.resolveAiAssistantSummary(),
+            mode: state?.mode || 'agentic-authoring',
+            state: state?.state || 'idle',
+            visibility: visibility ?? (this.aiAssistantOpen ? 'active' : 'minimized'),
+            badge: this.resolveAiAssistantBadge(),
+            icon: this.resolveAiAssistantIcon(),
+        });
+    }
+    hasAiAssistantSessionState() {
+        return !!this.aiAssistantPrompt.trim()
+            || !!this.aiAssistantViewState?.messages?.length
+            || !!this.aiAssistantViewState?.quickReplies?.length
+            || !!this.aiAssistantViewState?.pendingPatch
+            || !!this.aiAssistantViewState?.statusText?.trim()
+            || !!this.aiAssistantViewState?.errorText?.trim();
+    }
+    resolveAiAssistantSessionId() {
+        return `manual-form:${this.resolveAiAssistantRouteKey()}:${this.resolveAiAssistantOwnerId()}`;
+    }
+    resolveAiAssistantOwnerId() {
+        return (this.componentInstanceId() || this.safeAiAssistantFormId() || 'manual-form').trim() || 'manual-form';
+    }
+    safeAiAssistantFormId() {
+        try {
+            return String(this.formId() || '').trim();
+        }
+        catch {
+            return '';
+        }
+    }
+    resolveAiAssistantRouteKey() {
+        const routePath = this.route?.snapshot?.routeConfig?.path?.trim();
+        return routePath || 'local';
+    }
+    resolveAiAssistantSummary() {
+        const status = this.aiAssistantViewState?.statusText?.trim();
+        if (status)
+            return status;
+        const error = this.aiAssistantViewState?.errorText?.trim();
+        if (error)
+            return error;
+        const prompt = this.aiAssistantPrompt.trim();
+        if (prompt)
+            return prompt.length > 96 ? `${prompt.slice(0, 93)}...` : prompt;
+        const lastMessage = [...(this.aiAssistantViewState?.messages ?? [])].reverse()
+            .find((message) => message.role === 'assistant' || message.role === 'user');
+        if (lastMessage?.text) {
+            return lastMessage.text.length > 96 ? `${lastMessage.text.slice(0, 93)}...` : lastMessage.text;
+        }
+        return 'Assistente contextual do formulario manual.';
+    }
+    resolveAiAssistantBadge() {
+        const state = this.aiAssistantViewState?.state;
+        if (state === 'error')
+            return 'erro';
+        if (state === 'clarification')
+            return 'revisar';
+        if (state === 'review')
+            return 'preview';
+        if (state === 'success')
+            return 'ok';
+        return undefined;
+    }
+    resolveAiAssistantIcon() {
+        const state = this.aiAssistantViewState?.state;
+        if (state === 'error')
+            return 'error';
+        if (state === 'clarification')
+            return 'rule';
+        if (state === 'review')
+            return 'rate_review';
+        return 'auto_awesome';
+    }
+    collectAiAssistantFieldNames() {
+        return Array.from(new Set((this.instance?.currentConfig?.fieldMetadata ?? [])
+            .map((field) => field.name)
+            .filter((name) => typeof name === 'string' && !!name.trim())));
+    }
+    collectAiAssistantCounts() {
+        const config = this.instance?.currentConfig;
+        return {
+            sectionCount: config?.sections?.length ?? 0,
+            fieldCount: config?.fieldMetadata?.length ?? 0,
+            actionCount: [
+                config?.actions?.submit,
+                config?.actions?.cancel,
+                config?.actions?.reset,
+                ...(config?.actions?.custom ?? []),
+            ].filter(Boolean).length,
+        };
+    }
     async initialize(fromChanges) {
         this.syncHostFormGroupReference();
         if (!this.formId()) {
@@ -2540,20 +3246,20 @@ class ManualFormComponent {
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.17", type: ManualFormComponent, isStandalone: true, selector: "praxis-manual-form", inputs: { formId: { classPropertyName: "formId", publicName: "formId", isSignal: true, isRequired: true, transformFunction: null }, formTitle: { classPropertyName: "formTitle", publicName: "formTitle", isSignal: true, isRequired: false, transformFunction: null }, formDescription: { classPropertyName: "formDescription", publicName: "formDescription", isSignal: true, isRequired: false, transformFunction: null }, actions: { classPropertyName: "actions", publicName: "actions", isSignal: true, isRequired: false, transformFunction: null }, showHeader: { classPropertyName: "showHeader", publicName: "showHeader", isSignal: true, isRequired: false, transformFunction: null }, showActions: { classPropertyName: "showActions", publicName: "showActions", isSignal: true, isRequired: false, transformFunction: null }, enableAutoSave: { classPropertyName: "enableAutoSave", publicName: "enableAutoSave", isSignal: true, isRequired: false, transformFunction: null }, componentInstanceId: { classPropertyName: "componentInstanceId", publicName: "componentInstanceId", isSignal: true, isRequired: false, transformFunction: null }, enableCustomization: { classPropertyName: "enableCustomization", publicName: "enableCustomization", isSignal: true, isRequired: false, transformFunction: null }, persistenceOptions: { classPropertyName: "persistenceOptions", publicName: "persistenceOptions", isSignal: true, isRequired: false, transformFunction: null }, usePathNames: { classPropertyName: "usePathNames", publicName: "usePathNames", isSignal: true, isRequired: false, transformFunction: null }, autoSaveDebounceMs: { classPropertyName: "autoSaveDebounceMs", publicName: "autoSaveDebounceMs", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { submitted: "submitted", saved: "saved", resetEvent: "reset", metadataChange: "metadataChange" }, providers: [
             // Provide a ControlContainer at the host boundary so projected formControlName can resolve it
             { provide: ControlContainer, useExisting: ManualFormComponent },
-        ], queries: [{ propertyName: "formControls", predicate: FormControlName, descendants: true }], ngImport: i0, template: "<div class=\"pdx-manual-form\">\n  @if (showHeader()) {\n  <praxis-manual-form-header [instance]=\"instance\" [title]=\"formTitle()\" [description]=\"formDescription()\"\n    [enableCustomization]=\"enableCustomization()\" (editForm)=\"openFormEditor()\" (save)=\"handleSave()\"\n    (reset)=\"handleReset()\"></praxis-manual-form-header>\n  }\n\n  @if (enableCustomization()) {\n  <div class=\"pdx-manual-form__assistant\">\n    <praxis-ai-assistant [adapter]=\"aiAdapter\"></praxis-ai-assistant>\n  </div>\n  }\n\n  <form class=\"pdx-manual-form__form\" [formGroup]=\"formGroup\" (submit)=\"handleSubmit(); $event.preventDefault()\">\n    <ng-content></ng-content>\n  </form>\n\n  @if (showActions() && resolvedActions) {\n  <praxis-manual-form-actions [actions]=\"resolvedActions\"\n    (actionClick)=\"handleAction($event)\"></praxis-manual-form-actions>\n  }\n</div>\n", styles: [".pdx-manual-form{display:flex;flex-direction:column;gap:var(--pdx-manual-form-gap, 24px);color:var(--md-sys-color-on-surface)}.pdx-manual-form__form{display:grid;gap:var(--pdx-manual-form-field-gap, 16px);padding:var(--pdx-manual-form-padding, 20px);border-radius:var(--pdx-manual-form-radius, 16px);background:var(--pdx-manual-form-surface, var(--md-sys-color-surface-container));border:1px solid var(--pdx-manual-form-outline, var(--md-sys-color-outline-variant));box-shadow:var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__form:focus-within{border-color:var(--pdx-manual-form-focus, var(--md-sys-color-primary));box-shadow:0 0 0 2px var(--md-sys-color-primary),var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__assistant{display:flex;justify-content:flex-end}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: PraxisAiAssistantComponent, selector: "praxis-ai-assistant", inputs: ["adapter", "riskPolicy", "allowManualPatchEdit"] }, { kind: "component", type: ManualFormHeaderComponent, selector: "praxis-manual-form-header", inputs: ["instance", "title", "description", "saveLabel", "resetLabel", "enableCustomization", "editFormLabel"], outputs: ["save", "reset", "editForm"] }, { kind: "component", type: ManualFormActionsComponent, selector: "praxis-manual-form-actions", inputs: ["actions", "trackByFn"], outputs: ["actionClick"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+        ], queries: [{ propertyName: "formControls", predicate: FormControlName, descendants: true }], ngImport: i0, template: "<div class=\"pdx-manual-form\">\n  @if (showHeader()) {\n  <praxis-manual-form-header [instance]=\"instance\" [title]=\"formTitle()\" [description]=\"formDescription()\"\n    [enableCustomization]=\"enableCustomization()\" (editForm)=\"openFormEditor()\" (save)=\"handleSave()\"\n    (reset)=\"handleReset()\"></praxis-manual-form-header>\n  }\n\n  @if (enableCustomization()) {\n  <div class=\"pdx-manual-form__assistant\">\n    <button\n      type=\"button\"\n      class=\"pdx-manual-form__assistant-trigger\"\n      (click)=\"openAiAssistant()\"\n      aria-label=\"Abrir copiloto semantico Praxis do formulario manual\"\n      data-testid=\"praxis-manual-form-ai-assistant-trigger\"\n    >\n      Copiloto Praxis\n    </button>\n  </div>\n  }\n\n  @if (aiAssistantOpen && aiAssistantViewState) {\n  <praxis-ai-assistant-shell\n    [labels]=\"aiAssistantLabels\"\n    [mode]=\"aiAssistantViewState.mode\"\n    [state]=\"aiAssistantViewState.state\"\n    [contextItems]=\"aiAssistantViewState.contextItems\"\n    [attachments]=\"aiAssistantViewState.attachments\"\n    [messages]=\"aiAssistantViewState.messages\"\n    [quickReplies]=\"aiAssistantViewState.quickReplies\"\n    [prompt]=\"aiAssistantPrompt\"\n    [statusText]=\"aiAssistantViewState.statusText\"\n    [errorText]=\"aiAssistantViewState.errorText\"\n    [busy]=\"aiAssistantViewState.state === 'processing' || aiAssistantViewState.state === 'applying'\"\n    [canApply]=\"aiAssistantViewState.canApply\"\n    [layout]=\"aiAssistantLayout\"\n    testIdPrefix=\"praxis-manual-form-ai-assistant\"\n    (promptChange)=\"onAiAssistantPromptChange($event)\"\n    (submitPrompt)=\"onAiAssistantSubmit($event)\"\n    (apply)=\"onAiAssistantApply()\"\n    (retryTurn)=\"onAiAssistantRetry()\"\n    (cancelTurn)=\"onAiAssistantCancel()\"\n    (close)=\"closeAiAssistant()\"\n    (quickReply)=\"onAiAssistantQuickReply($event)\"\n    (editMessage)=\"onAiAssistantEditMessage($event)\"\n    (resendMessage)=\"onAiAssistantResendMessage($event)\"\n    (layoutChange)=\"onAiAssistantLayoutChange($event)\"\n  ></praxis-ai-assistant-shell>\n  }\n\n  <form class=\"pdx-manual-form__form\" [formGroup]=\"formGroup\" (submit)=\"handleSubmit(); $event.preventDefault()\">\n    <ng-content></ng-content>\n  </form>\n\n  @if (showActions() && resolvedActions) {\n  <praxis-manual-form-actions [actions]=\"resolvedActions\"\n    (actionClick)=\"handleAction($event)\"></praxis-manual-form-actions>\n  }\n</div>\n", styles: [".pdx-manual-form{display:flex;flex-direction:column;gap:var(--pdx-manual-form-gap, 24px);color:var(--md-sys-color-on-surface)}.pdx-manual-form__form{display:grid;gap:var(--pdx-manual-form-field-gap, 16px);padding:var(--pdx-manual-form-padding, 20px);border-radius:var(--pdx-manual-form-radius, 16px);background:var(--pdx-manual-form-surface, var(--md-sys-color-surface-container));border:1px solid var(--pdx-manual-form-outline, var(--md-sys-color-outline-variant));box-shadow:var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__form:focus-within{border-color:var(--pdx-manual-form-focus, var(--md-sys-color-primary));box-shadow:0 0 0 2px var(--md-sys-color-primary),var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__assistant{display:flex;justify-content:flex-end}.pdx-manual-form__assistant-trigger{border:0;border-radius:999px;padding:8px 14px;cursor:pointer;color:var(--md-sys-color-on-primary, #fff);background:var(--md-sys-color-primary, #3451d1);box-shadow:var(--md-sys-elevation-level2, 0 4px 12px rgba(0, 0, 0, .18))}.pdx-manual-form__assistant-trigger:hover{background:var(--md-sys-color-primary-container, #223fb6)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: PraxisAiAssistantShellComponent, selector: "praxis-ai-assistant-shell", inputs: ["labels", "mode", "state", "contextItems", "attachments", "messages", "quickReplies", "prompt", "statusText", "errorText", "testIdPrefix", "panelTestId", "submitTestId", "applyTestId", "primaryAction", "secondaryActions", "governanceActions", "busy", "canSubmit", "canApply", "submitOnEnter", "showAttachAction", "enablePastedAttachments", "enableFileAttachments", "attachmentAccept", "attachmentMultiple", "draggable", "resizable", "minWidth", "minHeight", "margin", "layout"], outputs: ["promptChange", "submitPrompt", "apply", "retryTurn", "cancelTurn", "shellAction", "close", "attach", "attachmentsPasted", "attachmentsSelected", "removeAttachment", "messageAction", "editMessage", "resendMessage", "quickReply", "layoutChange"] }, { kind: "component", type: ManualFormHeaderComponent, selector: "praxis-manual-form-header", inputs: ["instance", "title", "description", "saveLabel", "resetLabel", "enableCustomization", "editFormLabel"], outputs: ["save", "reset", "editForm"] }, { kind: "component", type: ManualFormActionsComponent, selector: "praxis-manual-form-actions", inputs: ["actions", "trackByFn"], outputs: ["actionClick"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ManualFormComponent, decorators: [{
             type: Component,
             args: [{ selector: 'praxis-manual-form', standalone: true, imports: [
                         CommonModule,
                         ReactiveFormsModule,
-                        PraxisAiAssistantComponent,
+                        PraxisAiAssistantShellComponent,
                         ManualFormHeaderComponent,
                         ManualFormActionsComponent,
                     ], providers: [
                         // Provide a ControlContainer at the host boundary so projected formControlName can resolve it
                         { provide: ControlContainer, useExisting: ManualFormComponent },
-                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"pdx-manual-form\">\n  @if (showHeader()) {\n  <praxis-manual-form-header [instance]=\"instance\" [title]=\"formTitle()\" [description]=\"formDescription()\"\n    [enableCustomization]=\"enableCustomization()\" (editForm)=\"openFormEditor()\" (save)=\"handleSave()\"\n    (reset)=\"handleReset()\"></praxis-manual-form-header>\n  }\n\n  @if (enableCustomization()) {\n  <div class=\"pdx-manual-form__assistant\">\n    <praxis-ai-assistant [adapter]=\"aiAdapter\"></praxis-ai-assistant>\n  </div>\n  }\n\n  <form class=\"pdx-manual-form__form\" [formGroup]=\"formGroup\" (submit)=\"handleSubmit(); $event.preventDefault()\">\n    <ng-content></ng-content>\n  </form>\n\n  @if (showActions() && resolvedActions) {\n  <praxis-manual-form-actions [actions]=\"resolvedActions\"\n    (actionClick)=\"handleAction($event)\"></praxis-manual-form-actions>\n  }\n</div>\n", styles: [".pdx-manual-form{display:flex;flex-direction:column;gap:var(--pdx-manual-form-gap, 24px);color:var(--md-sys-color-on-surface)}.pdx-manual-form__form{display:grid;gap:var(--pdx-manual-form-field-gap, 16px);padding:var(--pdx-manual-form-padding, 20px);border-radius:var(--pdx-manual-form-radius, 16px);background:var(--pdx-manual-form-surface, var(--md-sys-color-surface-container));border:1px solid var(--pdx-manual-form-outline, var(--md-sys-color-outline-variant));box-shadow:var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__form:focus-within{border-color:var(--pdx-manual-form-focus, var(--md-sys-color-primary));box-shadow:0 0 0 2px var(--md-sys-color-primary),var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__assistant{display:flex;justify-content:flex-end}\n"] }]
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"pdx-manual-form\">\n  @if (showHeader()) {\n  <praxis-manual-form-header [instance]=\"instance\" [title]=\"formTitle()\" [description]=\"formDescription()\"\n    [enableCustomization]=\"enableCustomization()\" (editForm)=\"openFormEditor()\" (save)=\"handleSave()\"\n    (reset)=\"handleReset()\"></praxis-manual-form-header>\n  }\n\n  @if (enableCustomization()) {\n  <div class=\"pdx-manual-form__assistant\">\n    <button\n      type=\"button\"\n      class=\"pdx-manual-form__assistant-trigger\"\n      (click)=\"openAiAssistant()\"\n      aria-label=\"Abrir copiloto semantico Praxis do formulario manual\"\n      data-testid=\"praxis-manual-form-ai-assistant-trigger\"\n    >\n      Copiloto Praxis\n    </button>\n  </div>\n  }\n\n  @if (aiAssistantOpen && aiAssistantViewState) {\n  <praxis-ai-assistant-shell\n    [labels]=\"aiAssistantLabels\"\n    [mode]=\"aiAssistantViewState.mode\"\n    [state]=\"aiAssistantViewState.state\"\n    [contextItems]=\"aiAssistantViewState.contextItems\"\n    [attachments]=\"aiAssistantViewState.attachments\"\n    [messages]=\"aiAssistantViewState.messages\"\n    [quickReplies]=\"aiAssistantViewState.quickReplies\"\n    [prompt]=\"aiAssistantPrompt\"\n    [statusText]=\"aiAssistantViewState.statusText\"\n    [errorText]=\"aiAssistantViewState.errorText\"\n    [busy]=\"aiAssistantViewState.state === 'processing' || aiAssistantViewState.state === 'applying'\"\n    [canApply]=\"aiAssistantViewState.canApply\"\n    [layout]=\"aiAssistantLayout\"\n    testIdPrefix=\"praxis-manual-form-ai-assistant\"\n    (promptChange)=\"onAiAssistantPromptChange($event)\"\n    (submitPrompt)=\"onAiAssistantSubmit($event)\"\n    (apply)=\"onAiAssistantApply()\"\n    (retryTurn)=\"onAiAssistantRetry()\"\n    (cancelTurn)=\"onAiAssistantCancel()\"\n    (close)=\"closeAiAssistant()\"\n    (quickReply)=\"onAiAssistantQuickReply($event)\"\n    (editMessage)=\"onAiAssistantEditMessage($event)\"\n    (resendMessage)=\"onAiAssistantResendMessage($event)\"\n    (layoutChange)=\"onAiAssistantLayoutChange($event)\"\n  ></praxis-ai-assistant-shell>\n  }\n\n  <form class=\"pdx-manual-form__form\" [formGroup]=\"formGroup\" (submit)=\"handleSubmit(); $event.preventDefault()\">\n    <ng-content></ng-content>\n  </form>\n\n  @if (showActions() && resolvedActions) {\n  <praxis-manual-form-actions [actions]=\"resolvedActions\"\n    (actionClick)=\"handleAction($event)\"></praxis-manual-form-actions>\n  }\n</div>\n", styles: [".pdx-manual-form{display:flex;flex-direction:column;gap:var(--pdx-manual-form-gap, 24px);color:var(--md-sys-color-on-surface)}.pdx-manual-form__form{display:grid;gap:var(--pdx-manual-form-field-gap, 16px);padding:var(--pdx-manual-form-padding, 20px);border-radius:var(--pdx-manual-form-radius, 16px);background:var(--pdx-manual-form-surface, var(--md-sys-color-surface-container));border:1px solid var(--pdx-manual-form-outline, var(--md-sys-color-outline-variant));box-shadow:var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__form:focus-within{border-color:var(--pdx-manual-form-focus, var(--md-sys-color-primary));box-shadow:0 0 0 2px var(--md-sys-color-primary),var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__assistant{display:flex;justify-content:flex-end}.pdx-manual-form__assistant-trigger{border:0;border-radius:999px;padding:8px 14px;cursor:pointer;color:var(--md-sys-color-on-primary, #fff);background:var(--md-sys-color-primary, #3451d1);box-shadow:var(--md-sys-elevation-level2, 0 4px 12px rgba(0, 0, 0, .18))}.pdx-manual-form__assistant-trigger:hover{background:var(--md-sys-color-primary-container, #223fb6)}\n"] }]
         }], ctorParameters: () => [], propDecorators: { formId: [{ type: i0.Input, args: [{ isSignal: true, alias: "formId", required: true }] }], formTitle: [{ type: i0.Input, args: [{ isSignal: true, alias: "formTitle", required: false }] }], formDescription: [{ type: i0.Input, args: [{ isSignal: true, alias: "formDescription", required: false }] }], actions: [{ type: i0.Input, args: [{ isSignal: true, alias: "actions", required: false }] }], showHeader: [{ type: i0.Input, args: [{ isSignal: true, alias: "showHeader", required: false }] }], showActions: [{ type: i0.Input, args: [{ isSignal: true, alias: "showActions", required: false }] }], enableAutoSave: [{ type: i0.Input, args: [{ isSignal: true, alias: "enableAutoSave", required: false }] }], componentInstanceId: [{ type: i0.Input, args: [{ isSignal: true, alias: "componentInstanceId", required: false }] }], enableCustomization: [{ type: i0.Input, args: [{ isSignal: true, alias: "enableCustomization", required: false }] }], persistenceOptions: [{ type: i0.Input, args: [{ isSignal: true, alias: "persistenceOptions", required: false }] }], usePathNames: [{ type: i0.Input, args: [{ isSignal: true, alias: "usePathNames", required: false }] }], autoSaveDebounceMs: [{ type: i0.Input, args: [{ isSignal: true, alias: "autoSaveDebounceMs", required: false }] }], submitted: [{ type: i0.Output, args: ["submitted"] }], saved: [{ type: i0.Output, args: ["saved"] }], resetEvent: [{ type: i0.Output, args: ["reset"] }], metadataChange: [{ type: i0.Output, args: ["metadataChange"] }], formControls: [{
                 type: ContentChildren,
                 args: [FormControlName, { descendants: true }]

package/index.d.ts

@@ -3,7 +3,7 @@ import { FormGroup, FormControlName, FormGroupName, AbstractControl, FormControl
 import { Observable, BehaviorSubject } from 'rxjs';
 import * as _angular_core from '@angular/core';
 import { AfterContentInit, OnDestroy, OnInit, OnChanges, TemplateRef, ViewContainerRef, SimpleChanges, InjectionToken } from '@angular/core';
-import { BaseAiAdapter, PatchResult } from '@praxisui/ai';
+import { BaseAiAdapter, PatchResult, PraxisAssistantTurnViewState, PraxisAssistantShellLayout, PraxisAssistantShellLabels, PraxisAssistantSessionSnapshot, PraxisAssistantShellQuickReply, PraxisAssistantShellMessage } from '@praxisui/ai';
 import { SettingsPanelRef } from '@praxisui/settings-panel';
 
 type ManualFormId = string;
@@ -154,10 +154,15 @@ declare class ManualFormActionsComponent {
 declare class ManualFormAiAdapter extends BaseAiAdapter<FormConfig> {
     private host;
     componentName: string;
+    componentId: string;
+    componentType: string;
     constructor(host: ManualFormComponent);
     getCurrentConfig(): FormConfig;
     getCapabilities(): AiCapability[];
     getRuntimeState(): Record<string, any>;
+    getDataProfile(): Record<string, any>;
+    getSchemaFields(): Record<string, any>[];
+    getAuthoringContext(): Record<string, any>;
     createSnapshot(): FormConfig;
     restoreSnapshot(snapshot: FormConfig): Promise<void>;
     applyPatch(patch: Partial<FormConfig>, _intent?: string): Promise<PatchResult>;
@@ -179,6 +184,10 @@ declare class ManualFormComponent implements AfterContentInit, OnDestroy {
     private readonly fieldKeyService;
     private readonly platformId;
     private readonly route;
+    private readonly aiApi;
+    private readonly assistantSessions;
+    private readonly aiTurnOrchestrator;
+    private readonly aiAssistantSessionEffect;
     private warnedMissingId;
     private readonly disableSelectorDefaults;
     private readonly selectorToControlType;
@@ -216,6 +225,13 @@ declare class ManualFormComponent implements AfterContentInit, OnDestroy {
     instance?: ManualFormInstance;
     resolvedActions?: FormActionsLayout;
     aiAdapter: ManualFormAiAdapter;
+    aiAssistantOpen: boolean;
+    aiAssistantPrompt: string;
+    aiAssistantViewState: PraxisAssistantTurnViewState | null;
+    aiAssistantLayout: PraxisAssistantShellLayout;
+    readonly aiAssistantLabels: Partial<PraxisAssistantShellLabels>;
+    private aiAssistantController;
+    private aiAssistantStateSubscription;
     formGroup: FormGroup;
     private readonly registeredDirectives;
     constructor();
@@ -246,6 +262,32 @@ declare class ManualFormComponent implements AfterContentInit, OnDestroy {
     /** Opens a simple form-level editor listing the fields and their visibility. */
     openFormEditor(): Promise<void>;
     applyConfigFromAdapter(config: FormConfig): void;
+    openAiAssistant(): void;
+    openAiAssistantFromSession(session: PraxisAssistantSessionSnapshot): void;
+    closeAiAssistant(): void;
+    onAiAssistantPromptChange(prompt: string): void;
+    onAiAssistantSubmit(prompt: string): void;
+    onAiAssistantApply(): void;
+    onAiAssistantRetry(): void;
+    onAiAssistantCancel(): void;
+    onAiAssistantQuickReply(reply: PraxisAssistantShellQuickReply): void;
+    onAiAssistantEditMessage(message: PraxisAssistantShellMessage): void;
+    onAiAssistantResendMessage(message: PraxisAssistantShellMessage): void;
+    onAiAssistantLayoutChange(layout: PraxisAssistantShellLayout): void;
+    private initializeAiAssistantController;
+    private buildAiAssistantContextItems;
+    private buildAiAssistantContextSnapshot;
+    private syncAiAssistantSession;
+    private hasAiAssistantSessionState;
+    private resolveAiAssistantSessionId;
+    private resolveAiAssistantOwnerId;
+    private safeAiAssistantFormId;
+    private resolveAiAssistantRouteKey;
+    private resolveAiAssistantSummary;
+    private resolveAiAssistantBadge;
+    private resolveAiAssistantIcon;
+    private collectAiAssistantFieldNames;
+    private collectAiAssistantCounts;
     private initialize;
     private collectFields;
     private componentKeyId;

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@praxisui/manual-form",
-  "version": "8.0.0-beta.20",
+  "version": "8.0.0-beta.22",
   "description": "Manual form toolkit for Praxis UI: container, instance factory and editor bridge for @praxisui/* fields.",
   "peerDependencies": {
     "@angular/common": "^20.1.0",
     "@angular/core": "^20.1.0",
-    "@praxisui/core": "^8.0.0-beta.20",
-    "@praxisui/dynamic-fields": "^8.0.0-beta.20",
-    "@praxisui/settings-panel": "^8.0.0-beta.20",
-    "@praxisui/metadata-editor": "^8.0.0-beta.20",
+    "@praxisui/core": "^8.0.0-beta.22",
+    "@praxisui/dynamic-fields": "^8.0.0-beta.22",
+    "@praxisui/settings-panel": "^8.0.0-beta.22",
+    "@praxisui/metadata-editor": "^8.0.0-beta.22",
     "@angular/cdk": "^20.1.0",
     "@angular/forms": "^20.1.0",
     "@angular/material": "^20.1.0",
     "@angular/router": "^20.1.0",
-    "@praxisui/ai": "^8.0.0-beta.20",
+    "@praxisui/ai": "^8.0.0-beta.22",
     "rxjs": "~7.8.0"
   },
   "dependencies": {