@praxisui/dynamic-form 9.0.0-beta.72 → 9.0.0-beta.74

package/ai/component-registry.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-07-12T00:55:35.176Z",
+  "generatedAt": "2026-07-16T21:05:04.797Z",
   "packageName": "@praxisui/dynamic-form",
-  "packageVersion": "9.0.0-beta.72",
+  "packageVersion": "9.0.0-beta.74",
   "sourceRegistry": "praxis-component-registry-ingestion",
   "sourceRegistryVersion": "1.0.0",
   "componentCount": 2,

package/fesm2022/{praxisui-dynamic-form-dynamic-form-agentic-authoring-turn-flow-CmFfx-VR.mjs → praxisui-dynamic-form-dynamic-form-agentic-authoring-turn-flow-w9V0aQ9B.mjs}

@@ -1,21 +1,22 @@
-import { firstValueFrom } from 'rxjs';
+import { Observable } from 'rxjs';
+import { withAuthoringScopePolicy } from '@praxisui/ai';
 
 class DynamicFormAgenticAuthoringTurnFlow {
     adapter;
-    aiApi;
+    turnClient;
     mode = 'agentic-authoring';
-    constructor(adapter, aiApi) {
+    constructor(adapter, turnClient) {
         this.adapter = adapter;
-        this.aiApi = aiApi;
+        this.turnClient = turnClient;
     }
-    async submit(request) {
+    submit(request) {
         const prompt = (request.prompt ?? '').trim();
         if (!prompt) {
-            return {
+            return Promise.resolve({
                 state: 'listening',
                 phase: 'capture',
                 statusText: '',
-            };
+            });
         }
         const componentId = this.adapter.componentId || request.componentId || 'praxis-dynamic-form';
         const componentType = this.adapter.componentType || request.componentType || 'form';
@@ -23,25 +24,207 @@ class DynamicFormAgenticAuthoringTurnFlow {
         const runtimeState = this.optionalJsonObject(this.adapter.getRuntimeState?.());
         const contextHints = this.mergeJsonObjects(this.optionalJsonObject(this.adapter.getAuthoringContext?.()), this.optionalJsonObject(request.action?.contextHints));
         if (this.shouldRestrictToInlineHelp(contextHints)) {
-            return this.toInlineHelpOnlyResult(prompt, request, contextHints);
+            return Promise.resolve(this.toInlineHelpOnlyResult(prompt, request, contextHints));
         }
-        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(currentState, runtimeState),
-            uiContextRef: {
+        const buildRequest = async () => {
+            await this.adapter.prepareAuthoringContext?.();
+            const preparedRuntimeState = this.optionalJsonObject(this.adapter.getRuntimeState?.()) ?? runtimeState;
+            const preparedContextHints = this.mergeJsonObjects(this.optionalJsonObject(this.adapter.getAuthoringContext?.()), this.optionalJsonObject(request.action?.contextHints));
+            const dataProfile = this.optionalJsonObject(this.adapter.getDataProfile?.());
+            const schemaFields = this.adapter.getSchemaFields?.()
+                ?.map((field) => this.toAiJsonObject(field))
+                .filter((field) => Object.keys(field).length > 0);
+            const patchRequest = withAuthoringScopePolicy({
+                componentId,
+                componentType,
+                userPrompt: prompt,
+                sessionId: request.sessionId,
+                clientTurnId: request.clientTurnId,
+                messages: this.toChatMessages(request.messages, prompt),
+                currentState,
+                currentStateDigest: this.buildCurrentStateDigest(currentState, preparedRuntimeState),
+                uiContextRef: {
+                    componentId,
+                    componentType,
+                },
+                ...(dataProfile ? { dataProfile } : {}),
+                ...(preparedRuntimeState ? { runtimeState: preparedRuntimeState } : {}),
+                ...(schemaFields?.length ? { schemaFields } : {}),
+                ...(preparedContextHints ? { contextHints: preparedContextHints } : {}),
+            }, {
                 componentId,
                 componentType,
-            },
-            ...(runtimeState ? { runtimeState } : {}),
-            ...(contextHints ? { contextHints } : {}),
+                componentLabel: this.adapter.componentName || 'formulário',
+            });
+            return {
+                ...patchRequest,
+                targetApp: 'praxis-ui-angular',
+                targetComponentId: componentId,
+                currentPage: currentState,
+                conversationMessages: this.toConversationMessages(request.messages),
+                pendingClarification: this.toPendingClarification(request),
+                attachmentSummaries: this.toAttachmentSummaries(request),
+                activeSemanticDecision: this.optionalJsonObject(request.activeSemanticDecision ?? request.action?.activeSemanticDecision),
+                contextHints: patchRequest.contextHints ?? null,
+            };
+        };
+        return this.submitViaAgenticStream(request, buildRequest);
+    }
+    submitViaAgenticStream(request, buildRequest) {
+        return new Observable((subscriber) => {
+            let closed = false;
+            let subscription = null;
+            const close = () => {
+                closed = true;
+                subscription?.unsubscribe();
+                subscription = null;
+            };
+            void buildRequest()
+                .then((turnRequest) => {
+                if (closed)
+                    return;
+                subscription = this.turnClient.streamEvents(turnRequest, {
+                    initialStatusText: 'Preparando o contexto seguro do formulário.',
+                    resultTimeoutMs: 90_000,
+                    streamTimeoutMs: 90_000,
+                }).subscribe({
+                    next: (event) => {
+                        if (closed)
+                            return;
+                        const result = this.toAgenticStreamTurnResult(event, request);
+                        subscriber.next(result);
+                        if (result.state !== 'processing') {
+                            subscriber.complete();
+                            close();
+                        }
+                    },
+                    error: (error) => {
+                        if (closed)
+                            return;
+                        subscriber.next(this.toAssistantErrorResult(error));
+                        subscriber.complete();
+                        close();
+                    },
+                });
+            })
+                .catch((error) => {
+                if (closed)
+                    return;
+                subscriber.next(this.toAssistantErrorResult(error));
+                subscriber.complete();
+                close();
+            });
+            return () => close();
+        });
+    }
+    toAgenticStreamTurnResult(event, request) {
+        if (event.kind === 'stream-started') {
+            return {
+                state: 'processing',
+                phase: 'contextualize',
+                statusText: 'Analisando o formulário e suas capacidades.',
+                sessionId: event.start.threadId,
+                clientTurnId: request.clientTurnId ?? event.start.turnId,
+                observationId: event.start.observationId ?? null,
+                canApply: false,
+            };
+        }
+        if (event.kind === 'stream-lifecycle') {
+            return {
+                state: 'processing',
+                phase: 'contextualize',
+                statusText: event.statusText,
+                sessionId: event.start.threadId,
+                clientTurnId: request.clientTurnId ?? event.start.turnId,
+                observationId: event.start.observationId ?? null,
+                canApply: false,
+                diagnostics: event.diagnostics
+                    ? { streamLifecycle: { phase: event.phase, ...event.diagnostics } }
+                    : undefined,
+            };
+        }
+        if (event.event.type === 'result') {
+            const payload = this.toRecord(event.event.payload) ?? {};
+            const rawResponse = this.toRecord(payload['response']) ?? payload;
+            const response = this.normalizeAgenticResponse(rawResponse);
+            return {
+                ...this.toTurnResult(this.compileAdapterResponse(response), request),
+                sessionId: event.event.threadId || request.sessionId,
+                clientTurnId: request.clientTurnId ?? event.event.turnId,
+            };
+        }
+        return this.turnClient.toTurnResult(event.event, request.clientTurnId);
+    }
+    normalizeAgenticResponse(response) {
+        const type = response['type'];
+        const normalizedType = type === 'patch'
+            || type === 'clarification'
+            || type === 'error'
+            || type === 'info'
+            ? type
+            : this.toRecord(response['patch']) || this.toRecord(response['compiledPatch'])
+                ? 'patch'
+                : 'info';
+        const patch = this.toRecord(response['patch']) ?? this.toRecord(response['compiledPatch']) ?? undefined;
+        const message = typeof response['message'] === 'string'
+            ? response['message']
+            : typeof response['assistantMessage'] === 'string'
+                ? response['assistantMessage']
+                : undefined;
+        return {
+            ...response,
+            type: normalizedType,
+            ...(patch ? { patch } : {}),
+            ...(message ? { message } : {}),
+        };
+    }
+    toConversationMessages(messages) {
+        return (messages ?? [])
+            .filter((message) => message.role === 'user' || message.role === 'assistant' || message.role === 'system')
+            .map((message) => ({
+            id: message.id,
+            role: message.role,
+            text: message.text,
+        }))
+            .filter((message) => message.text.trim().length > 0);
+    }
+    toPendingClarification(request) {
+        const pending = request.pendingClarification;
+        if (!pending?.sourcePrompt?.trim())
+            return null;
+        return {
+            sourcePrompt: pending.sourcePrompt,
+            questions: pending.questions.map((question) => question.label).filter(Boolean),
+            assistantMessage: pending.assistantMessage ?? null,
+            clientTurnId: pending.clientTurnId ?? null,
+            diagnostics: this.optionalJsonObject(pending.diagnostics) ?? null,
+        };
+    }
+    toAttachmentSummaries(request) {
+        return (request.attachments ?? []).map((attachment) => ({
+            id: attachment.id,
+            name: attachment.name,
+            kind: attachment.kind,
+            mimeType: attachment.mimeType ?? null,
+            sizeBytes: attachment.sizeBytes ?? null,
+            source: attachment.source ?? null,
+            hasPreview: !!attachment.previewUrl,
         }));
-        return this.toTurnResult(this.compileAdapterResponse(response), request);
+    }
+    toAssistantErrorResult(error) {
+        const message = error instanceof Error
+            ? error.message
+            : typeof error === 'string' && error.trim()
+                ? error
+                : 'Não foi possível concluir o pedido do formulário.';
+        return {
+            state: 'error',
+            phase: 'capture',
+            assistantMessage: `Não consegui concluir este pedido. ${message}`,
+            errorText: message,
+            canApply: false,
+            pendingPatch: null,
+        };
     }
     async apply(request) {
         const contextHints = this.optionalJsonObject(this.adapter.getAuthoringContext?.());

package/fesm2022/praxisui-dynamic-form.mjs

@@ -26,7 +26,7 @@ import * as i1 from '@praxisui/core';
 import { serializeEntityLookupValueForPayload, PraxisI18nService, PraxisIconDirective, providePraxisI18nConfig, RULE_PROPERTY_SCHEMA, FIELD_METADATA_CAPABILITIES, migrateFormLayoutRule, PraxisJsonLogicService, normalizeFormLayoutItems, deepMerge, createDefaultFormConfig, normalizeFormConfig as normalizeFormConfig$1, ensureIds, createEmptyRichContentDocument, isPraxisRuntimeGlobalActionEffect, ASYNC_CONFIG_STORAGE, withFormConfigSections, createFieldLayoutItem, getFormLayoutFieldNames, LoggerService, createCorporateLoggerConfig, ConsoleLoggerSink, GlobalActionService, ResourceQuickConnectComponent, composeHeadersWithVersion, buildApiUrl, mapFieldDefinitionsToMetadata, reconcileFormConfig, materializeFormLayoutFromMetadata, syncWithServerMetadata, PRAXIS_LOADING_CTX, evaluateFieldAccess, normalizeControlTypeKey, normalizePraxisEffectPolicy, buildPraxisEffectDistinctKey, getFormColumnFieldNames, resolveSpan, resolveOffset, resolveOrder, resolveHidden, buildSchemaIdStorageKeySegment, buildSchemaId, fetchWithETag, resolveControlTypeAlias, getTextTransformer, MemoryCacheAdapter, LocalStorageCacheAdapter, SchemaMetadataClient, CONNECTION_STORAGE, API_URL, PRAXIS_LOADING_RENDERER, FORM_HOOKS_PRESETS, EmptyStateCardComponent, isValidFormConfig, ComponentMetadataRegistry, FieldControlType, isRequiredGlobalActionPayloadMissing, GLOBAL_ACTION_CATALOG, PRAXIS_GLOBAL_ACTION_CATALOG, getGlobalActionCatalog, SURFACE_OPEN_I18N_NAMESPACE, getGlobalActionUiSchema, getRequiredGlobalActionPayloadKeys, hasMeaningfulGlobalActionPayloadValue, SurfaceOpenActionEditorComponent, SURFACE_OPEN_I18N_CONFIG, validateGlobalActionRefs, normalizeFormMetadata } from '@praxisui/core';
 import * as i1$1 from '@praxisui/dynamic-fields';
 import { getControlTypeCatalog, ConfirmDialogComponent, DynamicFieldLoaderDirective } from '@praxisui/dynamic-fields';
-import { BaseAiAdapter, AiBackendApiService, PraxisAssistantSessionRegistryService, PraxisAssistantTurnOrchestratorService, createPraxisAssistantViewportLayout, PraxisAiAssistantShellComponent } from '@praxisui/ai';
+import { BaseAiAdapter, AgenticAuthoringTurnClientService, PraxisAssistantSessionRegistryService, PraxisAssistantTurnOrchestratorService, createPraxisAssistantViewportLayout, PraxisAiAssistantShellComponent } from '@praxisui/ai';
 import { PraxisRichContent, PraxisRichContentConfigEditor } from '@praxisui/rich-content';
 import * as i6 from '@angular/material/menu';
 import { MatMenuModule } from '@angular/material/menu';
@@ -243,6 +243,12 @@ function normalizeSubmitPayload(data) {
     return normalizeTemporalStrings(normalizeDateArrays(data));
 }
 function normalizeTemporalStrings(value) {
+    // Date-only fields are converted by the field-aware submit pipeline. Keep
+    // native Date values intact here instead of treating them as generic records
+    // (which would otherwise turn them into an empty object).
+    if (value instanceof Date) {
+        return value;
+    }
     if (Array.isArray(value)) {
         return value.map((item) => normalizeTemporalStrings(item));
     }
@@ -373,9 +379,73 @@ function filterRecordForSubmit(value, fields, dirtyFields, scopePath) {
     return payload;
 }
 function normalizeFieldValueForSubmit(field, value, dirtyFields, fieldPath) {
-    const normalizedEntityLookupValue = normalizeEntityLookupValueForSubmit(field, value);
+    const normalizedDateValue = normalizeDateOnlyFieldValueForSubmit(field, value);
+    const normalizedEntityLookupValue = normalizeEntityLookupValueForSubmit(field, normalizedDateValue);
     return filterNestedArrayForSubmit(field, normalizedEntityLookupValue, dirtyFields, fieldPath);
 }
+/**
+ * Projects date-only controls into the ISO-8601 representation required by
+ * OpenAPI `format: date` / Java `LocalDate` contracts. A date field may hold
+ * a native Date (calendar selection) or its locale display value (manual
+ * masked input); neither presentation value should leak into the request.
+ */
+function normalizeDateOnlyFieldValueForSubmit(field, value) {
+    if (!isDateOnlyField(field) || value === null || value === undefined || value === '') {
+        return value;
+    }
+    if (value instanceof Date) {
+        return isValidDate(value) ? formatLocalIsoDate(value) : value;
+    }
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (isIsoDate(trimmed)) {
+        return trimmed;
+    }
+    const parsed = parseDayFirstDate(trimmed, field);
+    return parsed ? formatLocalIsoDate(parsed) : value;
+}
+function isDateOnlyField(field) {
+    const dataType = String(field.dataType ?? '').trim().toLowerCase();
+    if (dataType === 'date') {
+        return true;
+    }
+    const controlType = String(field.controlType ?? '').trim().toLowerCase();
+    return controlType === 'date' || controlType === 'datepicker' || controlType === 'date_picker';
+}
+function isIsoDate(value) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(value);
+}
+function parseDayFirstDate(value, field) {
+    const displayFormat = String(field.displayFormat ?? field.mask ?? '').toLowerCase();
+    if (!displayFormat.includes('dd') || !displayFormat.includes('mm') || !displayFormat.includes('yyyy')) {
+        return null;
+    }
+    const match = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/.exec(value);
+    if (!match) {
+        return null;
+    }
+    const day = Number(match[1]);
+    const month = Number(match[2]);
+    const year = Number(match[3]);
+    const parsed = new Date(year, month - 1, day);
+    return isValidDate(parsed) &&
+        parsed.getFullYear() === year &&
+        parsed.getMonth() === month - 1 &&
+        parsed.getDate() === day
+        ? parsed
+        : null;
+}
+function isValidDate(value) {
+    return !Number.isNaN(value.getTime());
+}
+function formatLocalIsoDate(value) {
+    const year = value.getFullYear();
+    const month = String(value.getMonth() + 1).padStart(2, '0');
+    const day = String(value.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
 function normalizeEntityLookupValueForSubmit(field, value) {
     if (!isEntityLookupField(field)) {
         return value;
@@ -1795,10 +1865,14 @@ class PraxisFormActionsComponent {
         }
         const buttons = [];
         const submitBtn = {
-            id: 'submit',
-            type: 'submit',
             color: 'primary',
             ...actions.submit,
+            // `actions.submit` is the reserved submit slot. Its visual configuration
+            // may be customized, but its runtime identity must remain canonical so a
+            // persisted editorial id cannot turn a submit button into a no-op custom
+            // action while its native submit event is prevented below.
+            id: 'submit',
+            type: 'submit',
             visible: actions.submit?.visible ?? actions.showSaveButton !== false,
             label: actions.submitButtonLabel || actions.submit?.label || 'ENVIAR',
         };
@@ -2008,6 +2082,8 @@ class PraxisFormActionsComponent {
         });
     }
     resolveButtonActionId(button) {
+        if (button.type === 'submit')
+            return 'submit';
         const id = button.id?.trim();
         if (id === 'submit' || id === 'cancel' || id === 'reset')
             return id;
@@ -7168,6 +7244,36 @@ class FormAiAdapter extends BaseAiAdapter {
             filledFields: filledCount,
         };
     }
+    getDataProfile() {
+        const config = this.host.config;
+        const actions = config?.actions;
+        return {
+            sectionCount: config?.sections?.length ?? 0,
+            fieldCount: config?.fieldMetadata?.length ?? 0,
+            ruleCount: config?.formRules?.length ?? 0,
+            actionCount: [
+                actions?.submit,
+                actions?.cancel,
+                actions?.reset,
+                ...(actions?.custom ?? []),
+            ].filter(Boolean).length,
+        };
+    }
+    getSchemaFields() {
+        return (this.host.config?.fieldMetadata ?? [])
+            .map((field) => ({
+            name: field.name,
+            label: field.label,
+            type: field.dataType ?? field.controlType,
+            controlType: field.controlType,
+            source: field.source ?? 'schema',
+            required: field.required === true,
+            readonly: field.readOnly === true,
+            disabled: field.disabled === true,
+            hidden: field.hidden === true,
+        }))
+            .filter((field) => typeof field.name === 'string' && !!field.name.trim());
+    }
     getAuthoringContext() {
         const manifest = PRAXIS_DYNAMIC_FORM_AUTHORING_MANIFEST;
         return {
@@ -10442,7 +10548,7 @@ class PraxisDynamicForm {
     enterpriseRuntimeContext;
     i18n = inject(PraxisI18nService);
     injector = inject(Injector);
-    aiApi = inject(AiBackendApiService);
+    agenticTurnClient = inject(AgenticAuthoringTurnClientService);
     assistantSessions = inject(PraxisAssistantSessionRegistryService);
     aiTurnOrchestrator = inject(PraxisAssistantTurnOrchestratorService);
     jsonLogic = inject(PraxisJsonLogicService);
@@ -10630,7 +10736,16 @@ class PraxisDynamicForm {
             : this.presentationModeGlobal === true;
     }
     getRenderableFieldsForLoader(fields) {
-        return fields.map((field) => this.materializeFieldPresentationPolicy(field));
+        return fields.map((field) => {
+            const materialized = this.materializeFieldPresentationPolicy(field);
+            if (!this.apiUrlEntry || materialized.apiUrlEntry === this.apiUrlEntry) {
+                return materialized;
+            }
+            // Dynamic field controls own their CRUD clients. Carry the resolved entry in the
+            // runtime-only metadata so option sources opened in detached hosts (dialogs,
+            // drawers, overlays) resolve against the same API as the form itself.
+            return { ...materialized, apiUrlEntry: this.apiUrlEntry };
+        });
     }
     materializeFieldPresentationPolicy(field) {
         let next = null;
@@ -10808,6 +10923,10 @@ class PraxisDynamicForm {
     entityHydrationPending = false;
     schemaCache = null;
     lastSchemaMeta;
+    schemaMetaPersistenceQueues = new Map();
+    formConfigPersistenceQueues = new Map();
+    formConfigPersistenceGenerations = new Map();
+    formConfigConflictBlockThrough = new Map();
     schemaRootHooks;
     destroy$ = new Subject();
     formValueChangesSubscription = null;
@@ -11999,11 +12118,12 @@ class PraxisDynamicForm {
     persistFormConfig(key, cfg) {
         if (!key) {
             this.warnMissingId();
-            return;
+            return Promise.resolve();
         }
         const toSave = this.removeEmptyContainersOnSave
             ? this.dynamicLayout.pruneEmptyContainers(cfg).config
             : cfg;
+        const snapshot = this.cloneFormConfigForPatch(toSave);
         try {
             const sections = Array.isArray(toSave.sections) ? toSave.sections.length : 0;
             const fields = Array.isArray(toSave.fieldMetadata) ? toSave.fieldMetadata.length : 0;
@@ -12013,11 +12133,50 @@ class PraxisDynamicForm {
             this.debugLog('[PDF] persistFormConfig: begin', { key, sections, fields, fieldNames });
         }
         catch { }
-        this.asyncConfigStorage.saveConfig(key, toSave).subscribe();
-        try {
-            this.debugLog('[PDF] persistFormConfig: done', { key });
-        }
-        catch { }
+        const generation = (this.formConfigPersistenceGenerations.get(key) ?? 0) + 1;
+        this.formConfigPersistenceGenerations.set(key, generation);
+        const previous = this.formConfigPersistenceQueues.get(key) ?? Promise.resolve();
+        const pending = previous
+            .catch(() => undefined)
+            .then(async () => {
+            if (generation <= (this.formConfigConflictBlockThrough.get(key) ?? 0))
+                return;
+            try {
+                await firstValueFrom(this.asyncConfigStorage.saveConfig(key, snapshot));
+                try {
+                    this.debugLog('[PDF] persistFormConfig: done', { key });
+                }
+                catch { }
+            }
+            catch (error) {
+                const status = Number(error?.status);
+                if (status !== 409 && status !== 412) {
+                    this.warnLog('[PDF] persistFormConfig: not acknowledged', error);
+                    return;
+                }
+                this.formConfigConflictBlockThrough.set(key, this.formConfigPersistenceGenerations.get(key) ?? generation);
+                const remote = await firstValueFrom(this.asyncConfigStorage.loadConfig(key))
+                    .catch(() => null);
+                const source = String(snapshot.metadata?.source || '').trim().toLowerCase();
+                if (remote && source === 'default') {
+                    this.config = normalizeFormConfig$1(remote);
+                    this.columnFieldsCache.clear();
+                    this.cdr.markForCheck();
+                }
+                this.warnLog('[PDF] persistFormConfig: concurrent version preserved', {
+                    key,
+                    status,
+                    resolution: remote ? 'remote-reloaded' : 'remote-unavailable',
+                });
+            }
+        });
+        this.formConfigPersistenceQueues.set(key, pending);
+        void pending.finally(() => {
+            if (this.formConfigPersistenceQueues.get(key) === pending) {
+                this.formConfigPersistenceQueues.delete(key);
+            }
+        });
+        return pending;
     }
     async createDefaultConfig() {
         try {
@@ -14562,6 +14721,11 @@ class PraxisDynamicForm {
         }
     }
     getFormActionEventId(button) {
+        // Native submit buttons are reserved form semantics. Do not let an
+        // editorial/persisted id reroute them to customAction after the browser
+        // submit event has been intentionally prevented by praxis-form-actions.
+        if (button.type === 'submit')
+            return 'submit';
         const id = button.id?.trim();
         if (id === 'submit' || id === 'cancel' || id === 'reset')
             return id;
@@ -14933,11 +15097,11 @@ class PraxisDynamicForm {
     initializeAiAssistantController() {
         if (this.aiAssistantController)
             return;
-        import('./praxisui-dynamic-form-dynamic-form-agentic-authoring-turn-flow-CmFfx-VR.mjs')
+        import('./praxisui-dynamic-form-dynamic-form-agentic-authoring-turn-flow-w9V0aQ9B.mjs')
             .then(({ DynamicFormAgenticAuthoringTurnFlow }) => {
             if (this.aiAssistantController)
                 return;
-            const flow = new DynamicFormAgenticAuthoringTurnFlow(this.aiAdapter, this.aiApi);
+            const flow = new DynamicFormAgenticAuthoringTurnFlow(this.aiAdapter, this.agenticTurnClient);
             const controller = this.aiTurnOrchestrator.createController(flow, {
                 componentId: this.aiAdapter.componentId || 'praxis-dynamic-form',
                 componentType: this.aiAdapter.componentType || 'form',
@@ -15375,28 +15539,61 @@ class PraxisDynamicForm {
             .then((value) => value ?? undefined)
             .catch(() => undefined);
     }
+    persistSchemaMeta(key, candidate) {
+        return this.enqueueSchemaMetaPersistence(key, candidate, (stored, pending) => {
+            const current = stored && typeof stored === 'object' && !Array.isArray(stored)
+                ? stored
+                : {};
+            const currentTimestamp = Date.parse(String(current['lastVerifiedAt'] || '')) || 0;
+            const pendingTimestamp = Date.parse(String(pending['lastVerifiedAt'] || '')) || 0;
+            return currentTimestamp > pendingTimestamp
+                ? { ...pending, ...current }
+                : { ...current, ...pending };
+        });
+    }
+    enqueueSchemaMetaPersistence(key, candidate, merge) {
+        const previous = this.schemaMetaPersistenceQueues.get(key) ?? Promise.resolve();
+        const pending = previous
+            .catch(() => undefined)
+            .then(() => this.reconcileSchemaMetaPersistence(key, candidate, merge));
+        this.schemaMetaPersistenceQueues.set(key, pending);
+        void pending.finally(() => {
+            if (this.schemaMetaPersistenceQueues.get(key) === pending) {
+                this.schemaMetaPersistenceQueues.delete(key);
+            }
+        });
+        return pending;
+    }
+    async reconcileSchemaMetaPersistence(key, candidate, merge) {
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const stored = await firstValueFrom(this.asyncConfigStorage.loadConfig(key))
+                .catch(() => null);
+            const reconciled = merge(stored, candidate);
+            if (JSON.stringify(stored) === JSON.stringify(reconciled))
+                return;
+            try {
+                await firstValueFrom(this.asyncConfigStorage.saveConfig(key, reconciled));
+                return;
+            }
+            catch (error) {
+                const status = Number(error?.status);
+                if ((status !== 409 && status !== 412) || attempt === 2)
+                    return;
+            }
+        }
+    }
     rememberSchemaMetaContext(schemaId) {
         const id = String(schemaId || '').trim();
         if (!id)
-            return;
+            return Promise.resolve();
         const indexKey = this.getSchemaMetaIndexKey();
         if (!indexKey)
-            return;
-        this.asyncConfigStorage
-            .loadConfig(indexKey)
-            .pipe(take(1))
-            .subscribe({
-            next: (stored) => {
-                const unique = new Set((Array.isArray(stored) ? stored : [])
-                    .map((item) => String(item || '').trim())
-                    .filter((item) => !!item));
-                unique.add(id);
-                this.asyncConfigStorage
-                    .saveConfig(indexKey, Array.from(unique))
-                    .pipe(take(1))
-                    .subscribe({ error: () => { } });
-            },
-            error: () => { },
+            return Promise.resolve();
+        return this.enqueueSchemaMetaPersistence(indexKey, [id], (stored, pending) => {
+            const unique = new Set([...(Array.isArray(stored) ? stored : []), ...pending]
+                .map((item) => String(item || '').trim())
+                .filter((item) => !!item));
+            return Array.from(unique);
         });
     }
     isSameSchemaContext(left, right) {
@@ -15661,8 +15858,8 @@ class PraxisDynamicForm {
                 metaToSave.serverHash = previousHash;
             }
             if (res.status === 304) {
-                this.asyncConfigStorage.saveConfig(scopedMetaKey, metaToSave).subscribe();
-                this.rememberSchemaMetaContext(currentSchemaId);
+                await this.persistSchemaMeta(scopedMetaKey, metaToSave);
+                await this.rememberSchemaMetaContext(currentSchemaId);
                 // Mirror meta in memory (config.metadata) without persisting config
                 try {
                     const mem = { ...(this.config.metadata || {}) };
@@ -15685,8 +15882,8 @@ class PraxisDynamicForm {
             // status === 200: server hash changed (or first verification without hash). Do not apply schema here.
             const newHash = res.schemaHash;
             metaToSave.serverHash = newHash;
-            this.asyncConfigStorage.saveConfig(scopedMetaKey, metaToSave).subscribe();
-            this.rememberSchemaMetaContext(currentSchemaId);
+            await this.persistSchemaMeta(scopedMetaKey, metaToSave);
+            await this.rememberSchemaMetaContext(currentSchemaId);
             // Mirror meta in memory (config.metadata) without persisting config
             try {
                 const mem = { ...(this.config.metadata || {}) };
@@ -18902,16 +19099,13 @@ class PraxisDynamicForm {
                     this.getSchemaMetaKey();
                 if (metaKey) {
                     const nowIso = new Date().toISOString();
-                    this.asyncConfigStorage
-                        .saveConfig(metaKey, {
+                    await this.persistSchemaMeta(metaKey, {
                         schemaId,
                         schemaContext,
                         serverHash: entry.schemaHash,
                         lastVerifiedAt: nowIso,
-                    })
-                        .pipe(take(1))
-                        .subscribe({ error: () => { } });
-                    this.rememberSchemaMetaContext(schemaId);
+                    });
+                    await this.rememberSchemaMetaContext(schemaId);
                 }
             }
             catch { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisui/dynamic-form",
-  "version": "9.0.0-beta.72",
+  "version": "9.0.0-beta.74",
   "description": "Angular dynamic form engine for Praxis UI: metadata-driven forms, hooks, and services integrating @praxisui/* packages.",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
@@ -9,13 +9,13 @@
     "@angular/forms": "^21.0.0",
     "@angular/material": "^21.0.0",
     "@angular/router": "^21.0.0",
-    "@praxisui/ai": "^9.0.0-beta.72",
-    "@praxisui/dynamic-fields": "^9.0.0-beta.72",
-    "@praxisui/metadata-editor": "^9.0.0-beta.72",
-    "@praxisui/rich-content": "^9.0.0-beta.72",
-    "@praxisui/settings-panel": "^9.0.0-beta.72",
-    "@praxisui/visual-builder": "^9.0.0-beta.72",
-    "@praxisui/core": "^9.0.0-beta.72",
+    "@praxisui/ai": "^9.0.0-beta.74",
+    "@praxisui/dynamic-fields": "^9.0.0-beta.74",
+    "@praxisui/metadata-editor": "^9.0.0-beta.74",
+    "@praxisui/rich-content": "^9.0.0-beta.74",
+    "@praxisui/settings-panel": "^9.0.0-beta.74",
+    "@praxisui/visual-builder": "^9.0.0-beta.74",
+    "@praxisui/core": "^9.0.0-beta.74",
     "rxjs": "^7.8.0"
   },
   "dependencies": {

package/src/lib/praxis-dynamic-form.json-api.md

@@ -24,6 +24,7 @@ source_of_truth:
   - "projects/praxis-dynamic-form/src/lib/ai/form-ai.adapter.ts"
   - "projects/praxis-ai/src/lib/core/models/assistant-context.models.ts"
   - "projects/praxis-ai/src/lib/core/services/assistant-session-registry.service.ts"
+  - "projects/praxis-ai/src/lib/core/services/agentic-authoring-turn-client.service.ts"
   - "projects/praxis-dynamic-form/src/lib/config-editor/praxis-dynamic-form-config-editor.ts"
   - "projects/praxis-dynamic-form/src/lib/utils/prepare-submit-payload.ts"
   - "projects/praxis-dynamic-fields/src/lib/directives/dynamic-field-loader.directive.ts"
@@ -34,8 +35,8 @@ source_of_truth:
   - "projects/praxis-core/src/lib/services/dynamic-form.service.ts"
   - "projects/praxis-core/src/lib/models/form/rule-property.schema.ts"
   - "projects/praxis-dynamic-form/docs/layout-items-visual-blocks.md"
-source_of_truth_last_verified: "2026-05-02"
-last_updated: "2026-05-02"
+source_of_truth_last_verified: "2026-07-16"
+last_updated: "2026-07-16"
 toc: true
 sidebar: true
 tags:
@@ -82,6 +83,8 @@ Contrato operacional:
 - a identidade canonica da sessao segue `form:{routeKey}:{componentInstanceId || formId || 'form'}`;
 - o contexto assistivel publico e `PraxisAssistantContextSnapshot`, com `identity`, `target`, `contextItems`, `authoringManifestRef`, `resourcePath`, `schemaFields`, digests seguros e hints de governanca;
 - o snapshot pode apontar para `field`, `schemaBackedField`, `localField`, `section`, `row`, `column`, `visualBlock`, `formAction`, `message` ou `rule`, mas nao deve transportar `form.value`, `rawFormData`, config completa, notas privadas, estado runtime bruto, diagnostics arbitrarios, `pendingPatch`, `File`, `Blob`, bytes, base64 ou `previewUrl`;
+- turnos do assistente usam `AgenticAuthoringTurnClientService` e `/api/praxis/config/ai/authoring/turn/stream/**`; indisponibilidade do transporte falha de forma fechada e nao reabre o caminho legado `getPatch`;
+- o grounding do turno pode incluir `schemaFields` e `dataProfile` estruturais produzidos pelo adapter, mas nunca valores dos controles; anexos sao reduzidos a nome, tipo, MIME, tamanho, origem e indicador de preview;
 - edicao local so pode ser aplicada quando a resposta for compilada para `componentEditPlan` validado pelo manifesto autoral do componente;
 - patches livres retornados por backend/LLM sem plano compilado sao rejeitados pelo turn flow;
 - pedidos sobre regra de negocio compartilhada, elegibilidade, compliance, LGPD, politica, acesso, aprovacao, publicacao, materializacao ou enforcement devem virar handoff governado para `domain-rules`, nao patch local de formulario;

package/types/praxisui-dynamic-form.d.ts

@@ -486,6 +486,8 @@ declare class FormAiAdapter extends BaseAiAdapter<FormConfig> {
     getCapabilities(): AiCapability[];
     getTaskPresets(): Record<string, string[]>;
     getRuntimeState(): Record<string, any>;
+    getDataProfile(): Record<string, any>;
+    getSchemaFields(): Record<string, any>[];
     getAuthoringContext(): Record<string, any>;
     compileAiResponse(response: Record<string, unknown>): AiResponseCompileResult | null;
     createSnapshot(): FormConfig;
@@ -692,7 +694,7 @@ declare class PraxisDynamicForm implements OnInit, OnChanges, OnDestroy {
     private enterpriseRuntimeContext?;
     private readonly i18n;
     private readonly injector;
-    private readonly aiApi;
+    private readonly agenticTurnClient;
     private readonly assistantSessions;
     private readonly aiTurnOrchestrator;
     private readonly jsonLogic;
@@ -871,6 +873,10 @@ declare class PraxisDynamicForm implements OnInit, OnChanges, OnDestroy {
     protected entityHydrationPending: boolean;
     private schemaCache;
     private lastSchemaMeta?;
+    private readonly schemaMetaPersistenceQueues;
+    private readonly formConfigPersistenceQueues;
+    private readonly formConfigPersistenceGenerations;
+    private readonly formConfigConflictBlockThrough;
     private schemaRootHooks?;
     private destroy$;
     private formValueChangesSubscription;
@@ -1230,6 +1236,9 @@ declare class PraxisDynamicForm implements OnInit, OnChanges, OnDestroy {
     private getSchemaMetaKeyForSchemaId;
     private getSchemaMetaKeyForContext;
     private loadStoredSchemaMeta;
+    private persistSchemaMeta;
+    private enqueueSchemaMetaPersistence;
+    private reconcileSchemaMetaPersistence;
     private rememberSchemaMetaContext;
     private isSameSchemaContext;
     private isStoredSchemaMetaForContext;