@sapui5/sap.suite.ui.generic.template 1.148.1 → 1.148.3

package/src/sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillFieldCollector.js

@@ -60,7 +60,7 @@ sap.ui.define([
          * @param {object} oObjectPage - the ObjectPage control (used to find SmartTables)
          * @param {object} oObjectPageModel - the OData model of the ObjectPage
          * @param {object} oTemplateUtils - FE template utilities (used for PresentationControlHandler)
-         * @param {object} mCollectionState - mutable collection state: { mCollectionRowContexts, mCollectionRowContextsByPath, mCollectionProperties, mCollectionEntityTypes }
+         * @param {object} mCollectionState - mutable collection state: { mCollectionRowContexts, mCollectionRowContextsByPath, mCollectionProperties, mCollectionEntityTypes, mCollectionEntitySets }
          * @param {function} fnGetLabel - function(oProperty) → string label
          */
         appendCollectionMap: function(mPropertyMap, oObjectPage, oObjectPageModel, oTemplateUtils, mCollectionState, fnGetLabel) {
@@ -69,6 +69,8 @@ sap.ui.define([
             mCollectionState.mCollectionRowContextsByPath = Object.create(null);
             mCollectionState.mCollectionProperties = Object.create(null);
             mCollectionState.mCollectionEntityTypes = Object.create(null);
+            mCollectionState.mCollectionEntitySets = Object.create(null);
+            mCollectionState.mCollectionAllowsCreation = Object.create(null);
 
             var aSmartTables = this.getObjectPageSmartTables(oObjectPage);
             if (!aSmartTables.length) {
@@ -154,6 +156,8 @@ sap.ui.define([
                 mCollectionState.mCollectionRowContextsByPath[sNavProperty] = mRowsByPath;
                 mCollectionState.mCollectionProperties[sNavProperty] = mPropertyByName;
                 mCollectionState.mCollectionEntityTypes[sNavProperty] = oEntityType;
+                mCollectionState.mCollectionEntitySets[sNavProperty] = oEntitySet;
+                mCollectionState.mCollectionAllowsCreation[sNavProperty] = this.resolveTableAllowsCreation(oSmartTable);
 
                 // Add collection entry to the LLM field mapping
                 mPropertyMap[sNavProperty] = {
@@ -177,9 +181,10 @@ sap.ui.define([
          * @param {object} oAiCallResult - flat map of { fieldName: aiValue } from the LLM
          * @param {object} oEntityType - OData entity type metadata
          * @param {object} oObjectPageContext - current ObjectPage binding context
+         * @param {object} oEntitySet - OData entity set metadata (for entity-set-level sap:updatable checks)
          * @returns {{ updatableFields: object, nonUpdatableFields: object }}
          */
-        getUpdatableAndNonUpdatableFields: function(oAiCallResult, oEntityType, oObjectPageContext) {
+        getUpdatableAndNonUpdatableFields: function(oAiCallResult, oEntityType, oObjectPageContext, oEntitySet) {
             var updatableFields = {};
             var nonUpdatableFields = {};
 
@@ -195,7 +200,7 @@ sap.ui.define([
                     nonUpdatableFields[sKey] = oAiCallResult[sKey];
                     return;
                 }
-                if (this.isEditable(oProperty, oObjectPageContext)) {
+                if (this.isEditable(oProperty, oObjectPageContext, oEntitySet)) {
                     updatableFields[sKey] = oAiCallResult[sKey];
                 } else {
                     nonUpdatableFields[sKey] = oAiCallResult[sKey];
@@ -250,18 +255,19 @@ sap.ui.define([
          * Checks whether a property is editable based on OData annotations.
          * Uses the current ObjectPage context object for dynamic field-control checks.
          *
-         * Priority: sap:updatable → FieldControl (EnumMember) → sap:field-control (dynamic value)
+         * Priority: entity-set-level sap:updatable → property sap:updatable → FieldControl (EnumMember) → sap:field-control (dynamic value)
          *
          * Field control values:
          *   0 = Hidden, 1 = ReadOnly, 3 = Editable, 7 = Mandatory (editable)
          *
          * @param {object} oProperty - OData property metadata
          * @param {object} oObjectPageContext - current ObjectPage binding context
+         * @param {object} oEntitySet - optional OData entity set metadata (for entity-set-level checks)
          * @returns {boolean}
          */
-        isEditable: function(oProperty, oObjectPageContext) {
+        isEditable: function(oProperty, oObjectPageContext, oEntitySet) {
             var oContextObject = oObjectPageContext && oObjectPageContext.getObject && oObjectPageContext.getObject();
-            return this.isEditableByContextObject(oProperty, oContextObject);
+            return this.isEditableByContextObject(oProperty, oContextObject, oEntitySet);
         },
 
         /**
@@ -270,14 +276,31 @@ sap.ui.define([
          *
          * @param {object} oProperty - OData property metadata
          * @param {object} oContextObject - plain JS object of the current row/entity data
+         * @param {object} oEntitySet - optional OData entity set metadata (for entity-set-level checks)
          * @returns {boolean}
          */
-        isEditableByContextObject: function(oProperty, oContextObject) {
+        isEditableByContextObject: function(oProperty, oContextObject, oEntitySet) {
             if (!oProperty) {
                 return false;
             }
 
-            // Check sap:updatable — static annotation, highest priority
+            // Check entity-set-level sap:updatable (entire entity set is read-only)
+            if (oEntitySet) {
+                var sEntitySetUpdatable = oEntitySet["sap:updatable"];
+                if (sEntitySetUpdatable === "false") {
+                    return false;
+                }
+                // sap:updatable-path: resolved against the context object (boolean property)
+                var sEntitySetUpdatablePath = oEntitySet["sap:updatable-path"];
+                if (sEntitySetUpdatablePath && oContextObject) {
+                    var bUpdatableFromPath = oContextObject[sEntitySetUpdatablePath];
+                    if (bUpdatableFromPath === false || bUpdatableFromPath === "false") {
+                        return false;
+                    }
+                }
+            }
+
+            // Check sap:updatable — static annotation on the property
             var sUpdatable = oProperty["sap:updatable"];
             if (sUpdatable) {
                 return sUpdatable !== "false";
@@ -304,32 +327,101 @@ sap.ui.define([
 
         /**
          * Builds a flat section tree for the Condensed view mode.
-         * All LLM result fields are grouped into a single unnamed section.
+         * Creates two sections: "Filled Fields" (updatable) and "Unfilled Fields" (non-updatable).
          *
          * @param {object} oLLMResult - flat map of { fieldName: value } from the LLM
+         * @param {object} oUpdatableFields - flat map of updatable fields only
+         * @param {object} oNonUpdatableFields - flat map of non-updatable fields only
          * @returns {Array} section tree array
          */
-        getSectionsForCondensedView: function(oLLMResult) {
-            return this._transformToTreeExpanded(oLLMResult);
+        getSectionsForCondensedView: function(oLLMResult, oUpdatableFields, oNonUpdatableFields) {
+            var aUpdatableKeys = Object.keys(oUpdatableFields || {});
+            var aNonUpdatableKeys = Object.keys(oNonUpdatableFields || {});
+            var aSections = [];
+            // Section 1: Filled Fields (updatable)
+            if (aUpdatableKeys.length > 0) {
+                aSections.push({
+                    title: "{@i18n>EASY_FILL_FILLED_FIELDS}",
+                    fields: [],
+                    children: [{
+                        title: "",
+                        fields: aUpdatableKeys,
+                        id: this._generateId("filledFields", aUpdatableKeys)
+                    }]
+                });
+            }
+
+            // Section 2: Unfilled Fields (non-updatable/read-only)
+            if (aNonUpdatableKeys.length > 0) {
+                aSections.push({
+                    title: "{@i18n>EASY_FILL_UNFILLED_FIELDS}",
+                    fields: [],
+                    children: [{
+                        title: "",
+                        fields: aNonUpdatableKeys,
+                        id: this._generateId("unfilledFields", aNonUpdatableKeys)
+                    }]
+                });
+            }
+
+            // Fallback: if no split provided, use old behavior
+            if (aSections.length === 0) {
+                return this._transformToTreeExpanded(oLLMResult);
+            }
+
+            return aSections;
         },
 
         /**
          * Builds a structured section tree for the ObjectPage view mode.
          * Mirrors the ObjectPage section/facet structure and filters to only include
-         * fields returned by the LLM.
+         * updatable fields returned by the LLM. Non-updatable (read-only) fields are
+         * excluded from the annotation sections and shown exclusively in the
+         * "Unfilled Fields" section appended at the end.
          *
          * @param {object} oEntityType - OData entity type metadata
          * @param {object} oLLMResult - flat map of { fieldName: value } from the LLM
          * @param {object} oRb - i18n resource bundle
+         * @param {object} oNonUpdatableFields - flat map of non-updatable fields only (optional)
          * @returns {Array} filtered section tree array
          */
-        getSectionsForObjectPageView: function(oEntityType, oLLMResult, oRb) {
+        getSectionsForObjectPageView: function(oEntityType, oLLMResult, oRb, oNonUpdatableFields) {
             var aSections = [];
             aSections = aSections
                 .concat(this._getSectionsForHeader(oEntityType, oRb))
                 .concat(this._getSectionsForObjectPageFacets(oEntityType));
             var aTree = this._transformToTree(aSections);
-            return this._filterTreeByLLMResult(aTree, oLLMResult);
+
+            // Annotation sections must only show updatable fields.
+            // Derive the updatable-only subset by removing non-updatable keys from oLLMResult
+            // so non-updatable fields do not appear in both annotation sections AND Unfilled Fields.
+            var aNonUpdatableSet = Object.keys(oNonUpdatableFields || {});
+            var oUpdatableResult = Object.keys(oLLMResult).reduce(function(oAcc, sKey) {
+                if (aNonUpdatableSet.indexOf(sKey) === -1) {
+                    oAcc[sKey] = oLLMResult[sKey];
+                }
+                return oAcc;
+            }, {});
+            var aFilteredTree = this._filterTreeByLLMResult(aTree, oUpdatableResult);
+            aFilteredTree = this._flattenTreeForObjectPageDialog(aFilteredTree);
+
+            // "Unfilled Fields" contains only non-updatable (read-only) fields.
+            // Editable fields that have no annotation section are silently dropped here —
+            // they already appear in their respective annotation-matched sections above.
+            var aNonUpdatableKeys = Object.keys(oNonUpdatableFields || {});
+            if (aNonUpdatableKeys.length > 0) {
+                aFilteredTree.push({
+                    title: "{@i18n>EASY_FILL_UNFILLED_FIELDS}",
+                    fields: [],
+                    children: [{
+                        title: "",
+                        fields: aNonUpdatableKeys,
+                        id: this._generateId("unfilledFields", aNonUpdatableKeys)
+                    }]
+                });
+            }
+
+            return aFilteredTree;
         },
 
         // ─── SmartTable Utilities ─────────────────────────────────────────────────
@@ -375,6 +467,49 @@ sap.ui.define([
             };
         },
 
+        /**
+         * Determines whether a SmartTable supports creation of new rows via inline mode.
+         * Supports "inline" createMode (with an enabled Create toolbar button) and
+         * "creationRows" / "creationRowsHiddenInEditMode" createMode (InlineCreationRows).
+         *
+         * @param {object} oSmartTable - sap.ui.comp.smarttable.SmartTable control
+         * @returns {boolean} true if new rows can be created for this table
+         */
+        resolveTableAllowsCreation: function(oSmartTable) {
+            var sCreateMode = oSmartTable.data("creationMode");
+            var bIsInlineCreationRows = sCreateMode === "creationRows" || sCreateMode === "creationRowsHiddenInEditMode";
+            var bIsInline = sCreateMode === "inline";
+
+            if (bIsInlineCreationRows) {
+                return true;
+            }
+
+            if (bIsInline) {
+                // Inline create requires the Create toolbar button to be enabled
+                var oTable = oSmartTable.getTable && oSmartTable.getTable();
+                if (!oTable) {
+                    return false;
+                }
+                var oToolbar = oSmartTable.getCustomToolbar && oSmartTable.getCustomToolbar();
+                if (!oToolbar) {
+                    return false;
+                }
+                var aButtons = oToolbar.getContent && oToolbar.getContent();
+                if (!Array.isArray(aButtons)) {
+                    return false;
+                }
+                var oCreateButton = aButtons.find(function(oControl) {
+                    return oControl.isA && oControl.isA("sap.m.Button") &&
+                        typeof oControl.getId === "function" &&
+                        oControl.getId().indexOf("add") >= 0 &&
+                        oControl.getEnabled && oControl.getEnabled();
+                });
+                return !!oCreateButton;
+            }
+
+            return false;
+        },
+
         // ─── Private Helpers ─────────────────────────────────────────────────────
 
         /**
@@ -482,23 +617,23 @@ sap.ui.define([
 
         /**
          * Filters a section tree to only include nodes that contain at least one LLM-returned field.
-         * Fields not matched to any section are grouped into an "unableToFill" catch-all node.
+         * Fields with no matching annotation section are silently dropped; the caller is responsible
+         * for surfacing them elsewhere (e.g. the "unfilledFields" section for non-updatable fields).
+         *
+         * @param {Array} aTree - section tree
+         * @param {object} oLLMResult - flat map of all LLM fields
+         * @returns {Array} filtered tree
          * @private
          */
         _filterTreeByLLMResult: function(aTree, oLLMResult) {
             var aRequestedKeys = Object.keys(oLLMResult);
-            var aMatchedKeys = new Set();
             var that = this;
 
             function filterNode(oNode, sParentPath) {
                 var sTitlePath = sParentPath ? (sParentPath + "_" + oNode.title) : oNode.title;
 
                 var aFilteredFields = oNode.fields.filter(function(sField) {
-                    if (aRequestedKeys.includes(sField)) {
-                        aMatchedKeys.add(sField);
-                        return true;
-                    }
-                    return false;
+                    return aRequestedKeys.includes(sField);
                 });
 
                 var aFilteredChildren = oNode.children
@@ -513,22 +648,58 @@ sap.ui.define([
                 };
             }
 
-            var aFilteredTree = aTree
+            return aTree
                 .map(function(oNode) { return filterNode(oNode, ""); })
                 .filter(function(oNode) { return oNode.fields.length > 0 || oNode.children.length > 0; });
+        },
 
-            // Any LLM fields that didn't map to a known section go into a special "unableToFill" node
-            var aUnmatchedKeys = aRequestedKeys.filter(function(sKey) { return !aMatchedKeys.has(sKey); });
-            if (aUnmatchedKeys.length > 0) {
-                aFilteredTree.push({
-                    title: "unableToFill",
-                    id: this._generateId("unableToFill", aUnmatchedKeys),
-                    fields: aUnmatchedKeys,
-                    children: []
-                });
+        /**
+         * Flattens nested ObjectPage section trees to one group level expected by the dialog fragment.
+         *
+         * EasyFill dialog binds SmartForm groups only to section.children (one level deep).
+         * If annotation facets produce deeper nesting, section titles can render while fields remain
+         * invisible because grandchildren are never bound as groups.
+         *
+         * @param {Array} aTree - filtered section tree
+         * @returns {Array} dialog-compatible tree with one-level children per section
+         * @private
+         */
+        _flattenTreeForObjectPageDialog: function(aTree) {
+            var that = this;
+
+            function collectRenderableGroups(oNode, sParentPath) {
+                var sTitlePath = sParentPath ? (sParentPath + "_" + oNode.title) : oNode.title;
+                var aGroups = [];
+
+                if (Array.isArray(oNode.fields) && oNode.fields.length > 0) {
+                    aGroups.push({
+                        title: oNode.title,
+                        id: that._generateId(sTitlePath, oNode.fields),
+                        fields: oNode.fields,
+                        children: []
+                    });
+                }
+
+                if (Array.isArray(oNode.children) && oNode.children.length > 0) {
+                    oNode.children.forEach(function(oChild) {
+                        aGroups = aGroups.concat(collectRenderableGroups(oChild, sTitlePath));
+                    });
+                }
+
+                return aGroups;
             }
 
-            return aFilteredTree;
+            return (aTree || []).map(function(oSection) {
+                var sSectionPath = oSection.title || "";
+                return {
+                    title: oSection.title,
+                    id: oSection.id,
+                    fields: [],
+                    children: collectRenderableGroups(oSection, sSectionPath)
+                };
+            }).filter(function(oSection) {
+                return Array.isArray(oSection.children) && oSection.children.length > 0;
+            });
         },
 
         /**
@@ -638,12 +809,14 @@ sap.ui.define([
                         // FieldGroup / Form — iterate Data array
                         oAnnotation.Data.forEach(function(oData) {
                             if (!this._isSupportedRecordType(oData.RecordType)) { return; }
+                            if (!oData.Value || !oData.Value.Path) { return; }
                             aRes.push({ title: aTempText, property: oData.Value.Path });
                         }.bind(this));
                     } else if (Array.isArray(oAnnotation)) {
                         // LineItem — iterate annotation array directly
                         oAnnotation.forEach(function(oAnno) {
                             if (!this._isSupportedRecordType(oAnno.RecordType)) { return; }
+                            if (!oAnno.Value || !oAnno.Value.Path) { return; }
                             aRes.push({ title: aTempText, property: oAnno.Value.Path });
                         }.bind(this));
                     } else if (oAnnotation.Value && oAnnotation.Value.Path) {
@@ -658,12 +831,18 @@ sap.ui.define([
         /**
          * Returns false for record types that EasyFill does not support rendering.
          * Currently excludes: IntentBasedNavigation, ForAnnotation, ForAction.
+         * Handles both fully-qualified names (com.sap.vocabularies.UI.v1.*) and
+         * alias form (UI.*) that OData metadata can return depending on the service.
          * @private
          */
         _isSupportedRecordType: function(sRecordType) {
-            return sRecordType !== "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation" &&
-                   sRecordType !== "com.sap.vocabularies.UI.v1.DataFieldForAnnotation" &&
-                   sRecordType !== "com.sap.vocabularies.UI.v1.DataFieldForAction";
+            if (!sRecordType) { return false; }
+            var sNormalized = sRecordType.replace("com.sap.vocabularies.UI.v1.", "UI.");
+            return sNormalized !== "UI.DataFieldForIntentBasedNavigation" &&
+                   sNormalized !== "UI.DataFieldForAnnotation" &&
+                   sNormalized !== "UI.DataFieldForAction" &&
+                   sNormalized !== "UI.DataFieldWithNavigationPath" &&
+                   sNormalized !== "UI.DataFieldWithIntentBasedNavigation";
         }
     };
 });

package/src/sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillFormRenderer.js

@@ -47,23 +47,40 @@ sap.ui.define([
          * @param {object} oLLMData - flat map of { fieldName: aiValue } from the LLM response
          * @returns {boolean} always returns true (used as a formatter return value in XML)
          */
-        populateSmartFields: function(sId, aFields, sEasyFillMode, oController, oTransientContextForEasyFill, oObjectPageContext, mUpdatableLookupMap, oLLMData) {
+        populateSmartFields: function(sId, aFields, sEasyFillMode, oController, oTransientContextForEasyFill, oObjectPageContext, mUpdatableLookupMap, oLLMData, fnOnFieldChange) {
             var oObjectPageLayout = oController.byId("EasyFillObjectPageLayout");
             if (!oObjectPageLayout || !Array.isArray(aFields) || aFields.length === 0) {
                 return true;
             }
 
+            var sPreviouslyLabel = oController.getView().getModel("i18n").getResourceBundle().getText("EASY_FILL_PREVIOUSLY_LABEL");
+
             // Defer injection until after the SmartForm has rendered into the DOM
             setTimeout(function() {
                 var oTargetGroup = null;
 
                 // Walk the ObjectPageLayout section hierarchy to find the group
-                // matching the given CustomData "id" value
+                // matching the given CustomData "id" value.
+                // In condensed mode the SmartForm may be nested inside a wrapper VBox
+                // (used to prevent BlockLayout from placing the table side-by-side with
+                // the SmartForm on resize). We therefore check one level deeper when the
+                // direct block is not a SmartForm.
                 oObjectPageLayout.getSections().forEach(function(oSection) {
                     oSection.getSubSections().forEach(function(oSubSection) {
                         oSubSection.getBlocks().forEach(function(oBlock) {
+                            var aSmartFormCandidates = [];
                             if (oBlock.isA("sap.ui.comp.smartform.SmartForm")) {
-                                oBlock.getGroups().forEach(function(oGroup) {
+                                aSmartFormCandidates.push(oBlock);
+                            } else if (typeof oBlock.getItems === "function") {
+                                // Look one level inside (e.g. condensed-mode wrapper VBox)
+                                oBlock.getItems().forEach(function(oItem) {
+                                    if (oItem.isA("sap.ui.comp.smartform.SmartForm")) {
+                                        aSmartFormCandidates.push(oItem);
+                                    }
+                                });
+                            }
+                            aSmartFormCandidates.forEach(function(oSmartForm) {
+                                oSmartForm.getGroups().forEach(function(oGroup) {
                                     var oMatchedCustomData = oGroup.getCustomData().find(function(oData) {
                                         return oData.getKey() === "id" && oData.getValue() === sId;
                                     });
@@ -71,7 +88,7 @@ sap.ui.define([
                                         oTargetGroup = oGroup;
                                     }
                                 });
-                            }
+                            });
                         });
                     });
                 });
@@ -85,7 +102,7 @@ sap.ui.define([
                 oTargetGroup.destroyGroupElements();
 
                 aFields.forEach(function(sKey) {
-                    var bIsEditable = mUpdatableLookupMap && !!mUpdatableLookupMap[sKey];
+                    var bIsEditable = Object.prototype.hasOwnProperty.call(mUpdatableLookupMap || {}, sKey);
 
                     var oGroupElement = new GroupElement({
                         useHorizontalLayout: false
@@ -114,6 +131,56 @@ sap.ui.define([
                         }
                     });
 
+                    if (!bIsEditable) {
+                        // Keep read-only behavior, but render like an input field (v4-like visual parity)
+                        oSmartField.addStyleClass("sapUiEasyFillReadOnlyInputLike sapMInputBaseContentWrapper");
+                    }
+
+                    // Notify on user edits so SmartForm validity can re-gate the Confirm button.
+                    if (bIsEditable && typeof fnOnFieldChange === "function") {
+                        oSmartField.attachChange(fnOnFieldChange);
+
+                        // Validate AI-seeded values on initial load — mirrors ObjectPage behaviour.
+                        //
+                        // In the OP, validation triggers because when a user TYPES a value the browser
+                        // fires a change event which causes UI5 to call setExternalValue() on the inner
+                        // control's binding. setExternalValue() has no fast-path: it always calls
+                        // parseValue → validateValue → OData value-list lookup. If the lookup fails the
+                        // binding calls setInvalidValue() + checkDataState() → ManagedObject fires
+                        // validationError → inner control gets valueState="Error" (red mark).
+                        //
+                        // SmartForm.check() / SmartField.checkValuesValidity() do NOT work for
+                        // AI-seeded values because SmartField._checkErrors() contains a fast-path:
+                        //   if (!isControlDirty() && formattedModelValue === displayedValue) → skip
+                        // AI values always satisfy this (model = display = AI value, user never typed),
+                        // so _checkErrors() short-circuits to "valid" without the OData lookup.
+                        //
+                        // Fix: after innerControlsCreated, call setExternalValue() on the inner
+                        // control's own binding with the currently displayed value. This is exactly
+                        // the same path the OP uses when the user types. For async types (TextArrangement
+                        // with ValueList) the call starts the OData lookup:
+                        //   valid value   → resolves quietly, no red mark
+                        //   invalid value → rejects → setInvalidValue + checkDataState → red mark
+                        // Non-async types fall through to a plain fnOnFieldChange call because
+                        // SmartForm.check() already handles them correctly (no fast-path for sync).
+                        oSmartField.attachInnerControlsCreated(function() {
+                            var oInnerControl = oSmartField.getFirstInnerControl();
+                            if (oInnerControl && typeof oInnerControl.getValue === "function") {
+                                var oBinding = oInnerControl.getBinding("value");
+                                var oType = oBinding && typeof oBinding.getType === "function" && oBinding.getType();
+                                if (oType && oType.async && typeof oBinding.setExternalValue === "function") {
+                                    // setExternalValue replicates the "user typed this value" path:
+                                    // parseValue → validateValue → OData lookup → validationError/Success
+                                    Promise.resolve(oBinding.setExternalValue(oInnerControl.getValue()))
+                                        .catch(Function.prototype)
+                                        .finally(fnOnFieldChange);
+                                    return;
+                                }
+                            }
+                            fnOnFieldChange();
+                        });
+                    }
+
                     /**
                      * "Previously:" SmartField (read-only):
                      * - Only shown for editable fields to display the current OP value for comparison
@@ -125,10 +192,9 @@ sap.ui.define([
                         enabled: false,
                         contextEditable: false,
                         showLabel: false,
-                        visible: bIsEditable,
                         layoutData: new ColumnElementData({
                             cellsSmall: 9,
-                            cellsLarge: 10
+                            cellsLarge: 9
                         }),
                         editableChanged: function(oEvent) {
                             // Always keep the "previously" field read-only
@@ -138,33 +204,42 @@ sap.ui.define([
                         }
                     });
 
-                    if (bIsEditable) {
-                        // Editable fields: primary field uses transient context (AI value),
-                        // preview field uses original OP context (current value)
+                    if (oTransientContextForEasyFill) {
+                        // Primary field always uses transient context to show AI-proposed value.
+                        // Field editability is controlled by bIsEditable.
                         oSmartField.setBindingContext(oTransientContextForEasyFill);
-                        oSmartFieldPrev.setBindingContext(oObjectPageContext);
 
-                        // Set the AI-suggested value on the transient context for this field
-                        oTransientContextForEasyFill.setProperty(sKey, oLLMData[sKey]);
+                        // Only seed the transient context with the AI-suggested value on the first
+                        // population. On subsequent calls (e.g. mode switch), the transient context
+                        // already holds the current value — overwriting it would discard user edits.
+                        if (oTransientContextForEasyFill.getProperty(sKey) === undefined) {
+                            oTransientContextForEasyFill.setProperty(sKey, oLLMData[sKey]);
+                        }
                     } else {
-                        // Non-editable fields: bound to the original OP context, display only
+                        // Fallback: without transient context, bind to original OP context.
                         oSmartField.setBindingContext(oObjectPageContext);
                     }
 
+                    // Previous value is always shown from the original ObjectPage context.
+                    oSmartFieldPrev.setBindingContext(oObjectPageContext);
+
                     // Build the GroupElement: [label+primary SmartField] [Previously: label] [preview SmartField]
                     oGroupElement.addElement(oSmartField); // SmartField provides the label
                     oGroupElement.addElement(new Text({
-                        text: "Previously:",
-                        visible: bIsEditable,
+                        text: sPreviouslyLabel,
                         layoutData: new ColumnElementData({
                             cellsSmall: 3,
-                            cellsLarge: 2
+                            cellsLarge: 3
                         })
-                    }));
+                    }).addStyleClass("sapEasyFillPreviouslyLabel"));
                     oGroupElement.addElement(oSmartFieldPrev);
                     oTargetGroup.addGroupElement(oGroupElement);
                 });
 
+                // Trigger initial SmartForm validation now that all SmartFields are rendered
+                if (typeof fnOnFieldChange === "function") {
+                    fnOnFieldChange();
+                }
                 oLogger.debug("populateSmartFields: populated " + aFields.length + " fields for group '" + sId + "'");
             }, 0);