@praxisui/page-builder 9.0.0-beta.88 → 9.0.0-beta.90

package/ai/component-registry.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-07-23T02:50:28.389Z",
+  "generatedAt": "2026-07-24T12:32:39.440Z",
   "packageName": "@praxisui/page-builder",
-  "packageVersion": "9.0.0-beta.88",
+  "packageVersion": "9.0.0-beta.90",
   "sourceRegistry": "praxis-component-registry-ingestion",
   "sourceRegistryVersion": "1.0.0",
   "componentCount": 1,

package/fesm2022/praxisui-page-builder.mjs

@@ -2939,6 +2939,10 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.projectKnowledgeCockpit.timelineEmpty': 'No safe events have been published for this proposal yet.',
     'praxis.pageBuilder.agentic.projectKnowledgeCockpit.rejected': 'Proposal rejected. No governed knowledge change was applied.',
     'praxis.pageBuilder.agentic.errors.applyLocal': 'Preview could not be applied.',
+    'praxis.pageBuilder.agentic.clientAction.undoApplied': 'I undid only the latest local change and preserved the earlier ones.',
+    'praxis.pageBuilder.agentic.clientAction.undoUnavailable': 'There is no local change available to undo on this page.',
+    'praxis.pageBuilder.agentic.errors.clientActionNotAuthorized': 'The requested local action is unavailable or does not match this page’s capabilities.',
+    'praxis.pageBuilder.agentic.errors.clientActionExecution': 'The requested local action could not be executed.',
     'praxis.pageBuilder.agentic.errors.componentId': 'Configure a component id before saving.',
     'praxis.pageBuilder.agentic.errors.invalidPreview': 'Generated preview is invalid.',
     'praxis.pageBuilder.agentic.errors.invalidPreviewWithDetails': 'I could not build a safe preview. Review the request or choose another data source.',
@@ -3560,6 +3564,10 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.projectKnowledgeCockpit.timelineEmpty': 'Ainda não há eventos seguros publicados para esta proposta.',
     'praxis.pageBuilder.agentic.projectKnowledgeCockpit.rejected': 'Proposta rejeitada. Nenhuma alteração no conhecimento governado foi aplicada.',
     'praxis.pageBuilder.agentic.errors.applyLocal': 'A pré-visualização não pôde ser aplicada.',
+    'praxis.pageBuilder.agentic.clientAction.undoApplied': 'Desfiz somente a última alteração local e preservei as anteriores.',
+    'praxis.pageBuilder.agentic.clientAction.undoUnavailable': 'Não há uma alteração local disponível para desfazer nesta página.',
+    'praxis.pageBuilder.agentic.errors.clientActionNotAuthorized': 'A ação local solicitada não está disponível ou não corresponde às capacidades desta página.',
+    'praxis.pageBuilder.agentic.errors.clientActionExecution': 'Não foi possível executar a ação local solicitada.',
     'praxis.pageBuilder.agentic.errors.componentId': 'Configure um id de componente antes de salvar.',
     'praxis.pageBuilder.agentic.errors.invalidPreview': 'A pré-visualização gerada é inválida.',
     'praxis.pageBuilder.agentic.errors.invalidPreviewWithDetails': 'Não consegui montar uma prévia segura. Revise o pedido ou escolha outra fonte de dados.',
@@ -15297,6 +15305,10 @@ class PageBuilderAgenticAuthoringTurnFlow {
             const componentCapabilities = await this.context.loadComponentCapabilities();
             const selectedWidgetKey = this.context.selectedWidgetKey();
             const intentResolution = await firstValueFrom(this.service.resolveIntent(this.buildIntentResolutionRequest(prompt, selectedWidgetKey, componentCapabilities, authoringContext)));
+            const clientActionResult = await this.completeSemanticClientAction(intentResolution);
+            if (clientActionResult) {
+                return clientActionResult;
+            }
             const intentQuickReplies = this.resolveShellQuickReplies(intentResolution);
             const intentAssistantMessage = this.normalizeAssistantMessageForQuickReplies(this.resolveIntentAssistantMessage(intentResolution), intentQuickReplies);
             if (intentAssistantMessage) {
@@ -15610,11 +15622,14 @@ class PageBuilderAgenticAuthoringTurnFlow {
         const status = this.decorateDashboardReviewStatus(this.context.describePreviewStatus(preview), intentResolution, preview);
         const reviewCanApply = false;
         const localReviewDiagnostics = this.buildLocalReviewDiagnostics(intentResolution, preview);
+        const repairReplies = this.reviewQuickReplies([], intentResolution, preview);
         return {
             state: 'review',
             phase: 'review',
             assistantMessage: status,
-            quickReplies: this.reviewQuickReplies([], intentResolution, preview),
+            quickReplies: repairReplies.length
+                ? repairReplies
+                : [this.dashboardQualityFallbackQuickReply(intentResolution, preview)],
             canApply: reviewCanApply,
             statusText: this.reviewStatusText(status, reviewCanApply),
             errorText: '',
@@ -17070,6 +17085,10 @@ class PageBuilderAgenticAuthoringTurnFlow {
         const assistantContent = this.toJsonObject(payload['assistantContent'])
             ?? this.toJsonObject(intentResolution.assistantContent)
             ?? null;
+        const clientAction = this.normalizeClientAction(payload['clientAction']);
+        if (clientAction) {
+            return this.completeDeclaredClientAction(clientAction, intentResolution);
+        }
         const backendCanApply = payload['canApply'] === true && !!preview?.valid;
         const terminalMaterializationIncomplete = backendCanApply
             && !this.hasCompiledPagePatch(preview);
@@ -18098,7 +18117,6 @@ class PageBuilderAgenticAuthoringTurnFlow {
     governedBlockedReviewQuickReplies(quickReplies, intentResolution, preview) {
         const replies = this.reviewQuickReplies(quickReplies, intentResolution, preview);
         if (intentResolution.artifactKind === 'dashboard'
-            && !this.dashboardReviewCanApply(intentResolution, preview)
             && replies.length === 0) {
             return [this.dashboardQualityFallbackQuickReply(intentResolution, preview)];
         }
@@ -18381,6 +18399,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
             contextHints: {
                 source: 'dashboard-quality-gate',
                 kind: 'dashboard-repair-action',
+                requiresBackendTerminalResult: true,
                 artifactKind: 'dashboard',
                 resourcePath,
                 warnings,
@@ -18999,6 +19018,9 @@ class PageBuilderAgenticAuthoringTurnFlow {
     }
     isContextualPreviewActionContext(contextHints) {
         const hints = contextHints ?? null;
+        if (hints?.['requiresBackendTerminalResult'] === true) {
+            return false;
+        }
         const hintSource = this.readString(hints, 'source');
         const hintKind = this.readString(hints, 'kind');
         return hintSource === 'component-capability-catalog'
@@ -19849,15 +19871,149 @@ class PageBuilderAgenticAuthoringTurnFlow {
             componentType: 'page-builder',
             componentLabel: 'page builder',
         });
+        const clientActions = (this.context.clientActions?.() ?? [])
+            .slice(0, 20)
+            .map((action) => ({ ...action }));
+        const contextualBase = clientActions.length
+            ? { ...scopedBase, clientActions }
+            : scopedBase;
         const includeLlmDiagnostics = this.context.includeLlmDiagnostics?.() === true;
         if (!includeLlmDiagnostics) {
-            return scopedBase;
+            return contextualBase;
         }
         return {
-            ...scopedBase,
+            ...contextualBase,
             includeLlmDiagnostics: true,
         };
     }
+    async completeSemanticClientAction(intentResolution) {
+        if (intentResolution.operationKind !== 'undo'
+            || intentResolution.changeKind !== 'undo_last_local_change') {
+            return null;
+        }
+        const declared = (this.context.clientActions?.() ?? [])
+            .find((action) => action.kind === 'local-undo'
+            && action.targetComponentId === this.context.targetComponentId);
+        if (!declared?.available) {
+            return {
+                state: 'success',
+                phase: 'summarize',
+                assistantMessage: this.context.tx('agentic.clientAction.undoUnavailable', 'Não há uma alteração local disponível para desfazer nesta página.'),
+                quickReplies: [],
+                canApply: false,
+                statusText: '',
+                errorText: '',
+                preview: null,
+                diagnostics: {
+                    intentResolution,
+                    clientAction: {
+                        kind: 'local-undo',
+                        declared: !!declared,
+                        available: false,
+                    },
+                },
+            };
+        }
+        return this.executeDeclaredClientAction(declared, intentResolution);
+    }
+    async completeDeclaredClientAction(requested, intentResolution) {
+        const declared = (this.context.clientActions?.() ?? []).find((action) => action.schemaVersion === requested.schemaVersion
+            && action.id === requested.id
+            && action.kind === requested.kind
+            && action.capabilityRef === requested.capabilityRef
+            && action.available
+            && requested.available
+            && action.targetComponentId === requested.targetComponentId
+            && action.targetComponentId === this.context.targetComponentId);
+        if (!declared || !this.context.executeClientAction) {
+            const message = this.context.tx('agentic.errors.clientActionNotAuthorized', 'A ação local solicitada não está disponível ou não corresponde às capacidades desta página.');
+            return {
+                state: 'error',
+                phase: 'summarize',
+                assistantMessage: message,
+                canApply: false,
+                statusText: '',
+                errorText: message,
+                preview: null,
+                diagnostics: {
+                    intentResolution,
+                    clientAction: {
+                        id: requested.id,
+                        kind: requested.kind,
+                        authorized: false,
+                    },
+                },
+            };
+        }
+        return this.executeDeclaredClientAction(declared, intentResolution);
+    }
+    async executeDeclaredClientAction(action, intentResolution) {
+        const executed = await this.context.executeClientAction(action);
+        if (!executed.success) {
+            const message = executed.error || this.context.tx('agentic.errors.clientActionExecution', 'Não foi possível executar a ação local solicitada.');
+            return {
+                state: 'error',
+                phase: 'summarize',
+                assistantMessage: message,
+                canApply: false,
+                statusText: '',
+                errorText: message,
+                preview: null,
+                diagnostics: {
+                    intentResolution,
+                    clientAction: {
+                        id: action.id,
+                        kind: action.kind,
+                        authorized: true,
+                        executed: false,
+                    },
+                },
+            };
+        }
+        return {
+            state: 'success',
+            phase: 'summarize',
+            assistantMessage: this.context.tx('agentic.clientAction.undoApplied', 'Desfiz somente a última alteração local e preservei as anteriores.'),
+            quickReplies: [],
+            canApply: false,
+            statusText: '',
+            errorText: '',
+            preview: null,
+            pendingPatch: null,
+            diagnostics: {
+                intentResolution,
+                clientAction: {
+                    id: action.id,
+                    kind: action.kind,
+                    authorized: true,
+                    executed: true,
+                },
+            },
+        };
+    }
+    normalizeClientAction(value) {
+        const action = this.toJsonObject(value);
+        const schemaVersion = this.readString(action ?? {}, 'schemaVersion');
+        const id = this.readString(action ?? {}, 'id');
+        const kind = this.readString(action ?? {}, 'kind');
+        const capabilityRef = this.readString(action ?? {}, 'capabilityRef');
+        const targetComponentId = this.readString(action ?? {}, 'targetComponentId');
+        if (schemaVersion !== 'praxis-agentic-authoring-client-action.v1'
+            || !id
+            || kind !== 'local-undo'
+            || !capabilityRef
+            || action?.['available'] !== true) {
+            return null;
+        }
+        return {
+            schemaVersion,
+            id,
+            kind,
+            capabilityRef,
+            available: true,
+            targetComponentId,
+        };
+    }
     withoutAgenticApplyTarget(contextHints) {
         if (!contextHints || !Object.prototype.hasOwnProperty.call(contextHints, 'agenticApplyTarget')) {
             return contextHints;
@@ -20145,6 +20301,7 @@ function projectKnowledgeTarget(changeSet, conceptKey) {
 }
 
 const AGENTIC_AUTHORING_TURN_INACTIVITY_TIMEOUT_MS = 180_000;
+const AGENTIC_LOCAL_PREVIEW_HISTORY_LIMIT = 20;
 const AGENTIC_PAGE_COMPOSITION_REQUEST_OUTPUT = 'agenticPageCompositionRequested';
 class DynamicPageBuilderComponent {
     dialog;
@@ -20251,6 +20408,8 @@ class DynamicPageBuilderComponent {
     agenticComponentCapabilities;
     agenticComponentCapabilitiesPromise;
     agenticTurnController;
+    agenticLocalPreviewHistory = [];
+    agenticLocalPreviewHistoryTruncated = false;
     agenticTurnCancel$ = new Subject();
     agenticTurnRunId = 0;
     agenticAuthoringTurnInactivityTimeoutMs = AGENTIC_AUTHORING_TURN_INACTIVITY_TIMEOUT_MS;
@@ -21047,6 +21206,7 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringError.set('');
         this.agenticAuthoringPreviewResult.set(null);
         this.agenticAuthoringMaterializationPending.set(false);
+        this.clearAgenticLocalPreviewHistory();
         this.agenticAuthoringSemanticDecision.set(null);
         this.agenticAuthoringSemanticResourcePresentationLabel.set(null);
         this.agenticAuthoringTurnResultRef.set(null);
@@ -22023,6 +22183,7 @@ class DynamicPageBuilderComponent {
             this.agenticAuthoringApplied.emit(result);
             this.agenticAuthoringPreviewResult.set(null);
             this.agenticAuthoringMaterializationPending.set(false);
+            this.clearAgenticLocalPreviewHistory();
             this.agenticAuthoringSemanticDecision.set(null);
             this.agenticAuthoringTurnResultRef.set(null);
             this.agenticAuthoringApplyTarget.set(null);
@@ -22909,6 +23070,8 @@ class DynamicPageBuilderComponent {
                 matchesApplyTarget: (target) => this.matchesCurrentAgenticApplyTarget(target),
                 enableTurnStream: () => this.agenticAuthoringEnableStreaming,
                 includeLlmDiagnostics: () => this.agenticAuthoringIncludeLlmDiagnostics,
+                clientActions: () => [this.agenticLocalUndoAction()],
+                executeClientAction: (action) => this.executeAgenticClientAction(action),
                 collectRuntimeComponentObservations: () => this.collectRuntimeComponentObservationsForAgenticTurn(),
                 resolveSelectedComponentAuthoringContext: (widgetKey) => this.resolveSelectedComponentAuthoringContext(widgetKey),
                 loadComponentCapabilities: () => this.loadAgenticComponentCapabilities(),
@@ -22934,18 +23097,24 @@ class DynamicPageBuilderComponent {
     }
     async applyAgenticPreviewLocally(result) {
         const adapter = new PageBuilderAiAdapter(this.createAdapterHost(), this.componentMetadata);
+        const snapshot = adapter.createSnapshot();
         const applied = await (result.compiledFormPatch?.patch?.page
             ? adapter.applyCompiledFormPatch(result.compiledFormPatch)
             : result.uiCompositionPlan
                 ? adapter.applyUiCompositionPlan(result.uiCompositionPlan)
                 : adapter.applyCompiledFormPatch(result.compiledFormPatch));
         if (!applied.success && this.isAgenticTableContractError(applied.error)) {
+            await adapter.restoreSnapshot(snapshot);
             return {
                 ...applied,
                 error: this.tx('agentic.errors.invalidTableContract', 'Encontrei a fonte de dados, mas a tabela proposta usa informações que esse componente não aceita. Vou ajustar para usar apenas campos compatíveis.'),
             };
         }
+        if (!applied.success) {
+            await adapter.restoreSnapshot(snapshot);
+        }
         if (applied.success) {
+            this.recordAgenticLocalPreview(snapshot);
             this.agenticAuthoringMaterializationPending.set(true);
             if (this.enableCustomization) {
                 this.enterPreviewMode();
@@ -22953,6 +23122,81 @@ class DynamicPageBuilderComponent {
         }
         return applied;
     }
+    agenticLocalUndoAction() {
+        return {
+            schemaVersion: 'praxis-agentic-authoring-client-action.v1',
+            id: 'page-builder.local-preview.undo',
+            kind: 'local-undo',
+            capabilityRef: 'page-builder.local-preview-history',
+            available: this.canUndoAgenticLocalPreview(),
+            targetComponentId: 'praxis-dynamic-page-builder',
+        };
+    }
+    async executeAgenticClientAction(action) {
+        if (action.kind !== 'local-undo'
+            || action.id !== 'page-builder.local-preview.undo'
+            || action.capabilityRef !== 'page-builder.local-preview-history'
+            || action.targetComponentId !== 'praxis-dynamic-page-builder') {
+            return {
+                success: false,
+                error: this.tx('agentic.errors.clientActionNotAuthorized', 'A ação local solicitada não corresponde às capacidades desta página.'),
+            };
+        }
+        return this.undoAgenticLocalPreview();
+    }
+    canUndoAgenticLocalPreview() {
+        const latest = this.agenticLocalPreviewHistory.at(-1);
+        return !!latest
+            && latest.componentId === this.resolveAgenticComponentId()
+            && latest.appliedPageFingerprint === this.agenticCurrentPageFingerprint();
+    }
+    async undoAgenticLocalPreview() {
+        if (!this.canUndoAgenticLocalPreview()) {
+            return {
+                success: false,
+                error: this.tx('agentic.clientAction.undoUnavailable', 'Não há uma alteração local disponível para desfazer nesta página.'),
+            };
+        }
+        const entry = this.agenticLocalPreviewHistory.pop();
+        const adapter = new PageBuilderAiAdapter(this.createAdapterHost(), this.componentMetadata);
+        try {
+            await adapter.restoreSnapshot(entry.snapshot);
+            this.agenticAuthoringMaterializationPending.set(this.agenticLocalPreviewHistoryTruncated || this.agenticLocalPreviewHistory.length > 0);
+            if (this.enableCustomization) {
+                this.enterPreviewMode();
+            }
+            return { success: true };
+        }
+        catch (error) {
+            this.agenticLocalPreviewHistory.push(entry);
+            return {
+                success: false,
+                error: this.describeAgenticError(error),
+            };
+        }
+    }
+    recordAgenticLocalPreview(snapshot) {
+        const componentId = this.resolveAgenticComponentId();
+        if (!componentId) {
+            return;
+        }
+        this.agenticLocalPreviewHistory.push({
+            componentId,
+            snapshot,
+            appliedPageFingerprint: this.agenticCurrentPageFingerprint(),
+        });
+        if (this.agenticLocalPreviewHistory.length > AGENTIC_LOCAL_PREVIEW_HISTORY_LIMIT) {
+            this.agenticLocalPreviewHistory.shift();
+            this.agenticLocalPreviewHistoryTruncated = true;
+        }
+    }
+    clearAgenticLocalPreviewHistory() {
+        this.agenticLocalPreviewHistory.length = 0;
+        this.agenticLocalPreviewHistoryTruncated = false;
+    }
+    agenticCurrentPageFingerprint() {
+        return JSON.stringify(this.currentPage());
+    }
     enterPreviewMode() {
         this.previewMode = true;
         this.runtimePreviewPageCache = undefined;

package/package.json

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

package/types/praxisui-page-builder.d.ts

@@ -1814,6 +1814,8 @@ declare class DynamicPageBuilderComponent implements OnChanges, OnDestroy {
     private agenticComponentCapabilities?;
     private agenticComponentCapabilitiesPromise?;
     private agenticTurnController?;
+    private readonly agenticLocalPreviewHistory;
+    private agenticLocalPreviewHistoryTruncated;
     private readonly agenticTurnCancel$;
     private agenticTurnRunId;
     private agenticAuthoringTurnInactivityTimeoutMs;
@@ -1998,6 +2000,13 @@ declare class DynamicPageBuilderComponent implements OnChanges, OnDestroy {
     private isComponentConfigEditorContextResult;
     private ensureAgenticTurnController;
     private applyAgenticPreviewLocally;
+    private agenticLocalUndoAction;
+    private executeAgenticClientAction;
+    private canUndoAgenticLocalPreview;
+    private undoAgenticLocalPreview;
+    private recordAgenticLocalPreview;
+    private clearAgenticLocalPreviewHistory;
+    private agenticCurrentPageFingerprint;
     private enterPreviewMode;
     private toPresentationRuntimePage;
     private toAuthoringRuntimePage;