review

sr-remsha · sr-remsha · commit 2874248a2b85 · 2025-04-25T11:41:23.000+02:00
diff --git a/docs/tutorials/1.developers/4.apps-development/3.enable-app.md b/docs/tutorials/1.developers/4.apps-development/3.enable-app.md
@@ -1,38 +1,42 @@
 # How to Enable Apps in DIAL
 
-This document describes the process for enabling applications in DIAL to make them available for users. The development of applications are beyond the scope of this document.
+## Introduction
+
+DIAL can serve as a universal platform that allows using both [DIAL-native applications](#dial-native-applications) and [applications developed on other platforms](#bring-apps-to-dial).
+
+This document describes the process for enabling applications in DIAL to make them available for users. The development of applications are beyond the scope of this document. You can develop applications following [Unified API of DIAL](https://dialx.ai/dial_api) and [DIAL SDK](https://github.com/epam/ai-dial-sdk).
 
 The prerequisite to the application enablement in DIAL, is a running container with your application. 
 
-> You can develop applications following DIAL Unified API and DIAl SDK.
+To enable a DIAL-native application in DIAL, you can either modify the DIAL Core configuration directly or use the DIAL API.
+
+**Important**: Apps enabled via the DIAL API, can be modified using API or UI wizards, provided the corresponding permissions are enabled. Apps enabled via the DIAL Core config, are immutable and cannot be modified via UI or API. The owner of such apps is always the admin of the DIAL setup.
+
 
-## Introduction
 
-DIAL can serve as a universal platform that allows using both DIAL-native applications and [applications developed on other platforms](#bring-apps-to-dial).
+## DIAL-Native Applications
 
 DIAL-native applications adhere to the [Unified API of DIAL](https://dialx.ai/dial_api), which allows them to be used as building blocks for other DIAL-native applications. Refer to [Agentic Platform](/docs/platform/0.architecture-and-concepts/4.agentic-platform.md) to learn more about agents in DIAL.
 
 These applications can be categorized as either schema-rich or schema-less:
 
-* [Schema-rich applications](#enable-schema-rich-applications) are associated with a specific application type, the structure of which is defined by a JSON schema. The schema specifies the application's properties, bringing them to another abstraction level and enabling end-users to create and configure applications of this type—that would otherwise be restricted or inaccessible. Application types can be seen as templates for creating applications of that type.
-* [Schema-less applications](#enable-schema-less-applications), on the other hand, are not associated with any specific application type and can be enabled by supplying the app's endpoint and some other voluntary parameters.
+##### Schema-rich applications
 
-DIAL SaaS edition includes application types such as Quick app, Code app and Mindmap. In self-hosted deployments of DIAL, you can add new application types, featuring custom UIs and wizards and enabling end-users to create applications of that type. Refer to [Agentic Platform](/docs/platform/0.architecture-and-concepts/4.agentic-platform.md#application-types) to learn more about available application types.
+[Schema-rich applications](#enable-schema-rich-applications) are defined by a JSON schema that conforms to the main [meta schema](https://dialx.ai/dial_api#tag/Applications/operation/getMetaSchemaOfCustomApplicationSchema). The JSON schema specifies the application type's structure, including properties, endpoints, and configuration parameters. Refer to [DIAL API](https://dialx.ai/dial_api#tag/Applications/operation/listCustomApplicationSchemas) to see examples. It may also include a URL for an application editor, enabling a wizard in the UI for creating applications. Using schemas makes application configuration accessible to end-users by exposing properties that would otherwise remain part of the application's internal environment.
 
-To enable a DIAL-native application in DIAL, you can either modify the DIAL Core configuration directly or use the DIAL API.
+Schema-rich applications are usually associated with specific **Application Types** can be seen as templates for creating applications of that type. DIAL SaaS edition includes application types such as Quick app, Code app and Mindmap. In self-hosted deployments of DIAL, you can add new application types, featuring custom UIs and wizards and enabling end-users to create applications of that type. Refer to [Agentic Platform](/docs/platform/0.architecture-and-concepts/4.agentic-platform.md#application-types) to learn more about available application types.
 
-**Important**: Apps enabled via the DIAL API, can be modified using API or UI wizards, provided the corresponding permissions are enabled. Apps enabled via the DIAL Core config, are immutable and cannot be modified via UI or API. The owner of such apps is always the admin of the DIAL setup.
+##### Schema-less applications
 
-## Enable Schema-Rich Applications
+[Schema-less applications](#enable-schema-less-applications), on the other hand, are not associated with any specific application type and can be enabled by supplying the app's endpoint and some other parameters supported by [DIAL Core](https://github.com/epam/ai-dial-core?tab=readme-ov-file#dynamic-settings).
 
-Schema-rich applications are defined by a JSON schema, which conforms to the main meta schema. The application type schema includes properties, endpoints, and other parameters that define the application type structure and configuration. Schema can also include a URL of the application editor, which can be used as a wizard on UI to create applications of this type.
+## Enable Schema-Rich Applications
 
-##### To enable a schema-rich application in DIAL, follow these steps:
+You can enable schema-rich apps in DIAL either using DIAL API or by a direct modification of the DIAL Core configuration.
 
-1. Add an application type and its schema directly to the DIAL Core configuration, unless it is already present and you want to use it.
-2. After that, you can create apps of this type using DIAL API or directly including them in the DIAL Core config. Some application types allow creating apps using UI wizards as well.
+**Prerequisite**: You must have a running container with your app accessible via the endpoint specified by the schema.
 
-In any case, when a new implementation of the application type is created, its configuration is saved as a BLOB in the DIAL Core file system with a JSON object that must correspond to the schema of this particular application type. This file is available vial the DIAL API, according to the defined Auth Matrix.
+In any case, the configuration of the enabled app is saved as a BLOB in the DIAL Core file system with a JSON object that must correspond to the schema of a particular application type. This file is available vial the [DIAL API](https://dialx.ai/dial_api#tag/Applications/operation/getCustomApplicationSchema), according to the defined [Auth Matrix](/docs/tutorials/1.developers/4.apps-development/2.auth-matrix.md) for a specific application.
 
 ### Using API
 
@@ -43,11 +47,11 @@ You can use the DIAL API to enable a schema-rich application of a specific type.
 Send a [PUT](https://dialx.ai/dial_api#tag/Applications/operation/saveCustomApplication) request to DIAL Core, where you provide:
 
 * Standard parameters for the application. Refer to [dynamic setting of DIAL Core](https://github.com/epam/ai-dial-core?tab=readme-ov-file#dynamic-settings).
-* `applicationTypeSchemaId`: The identifier of the schema for the application type you want to use as a template. You can retrieve available schemas via the [GET Schemas](https://rail-landing.staging.deltixhub.io/dial_api#tag/Applications/operation/listCustomApplicationSchemas) API call. **Important**: all requests are routed to endpoints defined by the schema.
+* `applicationTypeSchemaId`: The identifier of the schema for the application type you want to use as a template. You can retrieve available schemas via the [GET Schemas](https://rail-landing.staging.deltixhub.io/dial_api#tag/Applications/operation/listCustomApplicationSchemas) API call.
 * `applicationProperties`: A valid JSON object representing the application's structure, conforming to the specified schema. If the JSON object is invalid, the request will fail.
   - If `applicationTypeSchemaId` is absent or `NULL`, `applicationProperties` are not required.
   - If `applicationTypeSchemaId` is provided but `applicationProperties` are `NULL`, the application is considered a "stub" and can be updated later, but completion requests will not be possible.
-  - For applications with schemas, all requests are routed to endpoints specified in `applicationProperties`. **Note**: Endpoints provided outside the `applicationProperties` object will fail the request.
+  - For applications with schemas, all requests are routed **ONLY** to endpoints specified in the schema.
 
     ```json
     //Example for your reference
@@ -69,7 +73,7 @@ Send a [PUT](https://dialx.ai/dial_api#tag/Applications/operation/saveCustomAppl
 
 #### UI Wizard
 
-Application types in DIAL can include UI wizards, which simplify the creation of applications of specific types by end-users on the DIAL UI. Apps built using these wizards are automatically registered in DIAL Core and can be displayed in the DIAL Marketplace if corresponding permissions are enabled.
+Schemas of application types can include UI wizards, which simplify the creation of applications of specific types by end-users on the DIAL UI. Apps built using these wizards are automatically registered in DIAL Core and can be displayed in the DIAL Marketplace if corresponding permissions are enabled.
 
 > Refer to [User guide](/docs/tutorials/0.user-guide.md#applications) to learn how to create applications using wizards.
 
@@ -79,23 +83,23 @@ If your application type's schema includes `dial:applicationTypeEditorUrl`, the
 
 DIAL setup admin can enable a schema-rich application by including a JSON object with apps configurations in the DIAL Core configuration.
 
-**Important**: Apps added through direct modification of the DIAL Core configuration are immutable and cannot be edited via the UI or API, including by setup administrators. These apps are owned by the DIAL admin and are ideal for use cases where the app is configured once and remains unchanged, becoming available to users with predefined roles and limits. 
+**Important**: Apps added through direct modification of the DIAL Core configuration are immutable and cannot be edited via the UI or API, including by setup administrators. These apps are owned by the DIAL admin and are ideal for use cases where the app is configured once and remains unchanged, becoming available to users with predefined roles and permissions. 
 
 ## Enable Schema-Less Applications
 
 Schema-less applications are not associated with any specific application type and can be enabled by supplying the app's endpoint and some other parameters. Refer to [dynamic setting of DIAL Core](https://github.com/epam/ai-dial-core?tab=readme-ov-file#dynamic-settings) to see all the supported parameters for applications.
 
 To enable schema-less applications in DIAL, you can either include a JSON object with apps configurations in the DIAL Core configuration or use the DIAL API.
 
-In any case, the configuration of an application is saved as a BLOB in the DIAL Core file system with a JSON object. This file is available via the DIAL API, according to the defined Auth Matrix.
+**Prerequisite**: You must have a running container with your app accessible via the endpoint you provide in the request.
+
+In any case, the configuration of an application is saved as a BLOB in the DIAL Core file system with a JSON object. This file is available via the [DIAL API](https://dialx.ai/dial_api#tag/Applications/operation/getCustomApplicationSchema), according to the defined [Auth Matrix](/docs/tutorials/1.developers/4.apps-development/2.auth-matrix.md) for a specific application.
 
 ### Using API
 
 **Important**: Apps enabled via the DIAL API, can be modified using API or UI wizards, provided the corresponding permissions are enabled.
 
-**Prerequisite**: You must have a running container with your app accessible via the endpoint you provide in the request.
-
-Use the [PUT call](https://dialx.ai/dial_api#tag/Applications/operation/saveCustomApplication), where in the request body you provide specific endpoints and parameters for your application. You can see them in DIAL Core documentation under the [dynamic setting](https://github.com/epam/ai-dial-core?tab=readme-ov-file#dynamic-settings) for `applications`.
+Send a [PUT](https://dialx.ai/dial_api#tag/Applications/operation/saveCustomApplication) request to DIAL Core, where in the request body you provide specific endpoints and parameters for your application. You can see them in DIAL Core documentation under the [dynamic setting](https://github.com/epam/ai-dial-core?tab=readme-ov-file#dynamic-settings) for `applications`.
 
 ```json
 //Example for your reference
@@ -128,7 +132,7 @@ Use the [PUT call](https://dialx.ai/dial_api#tag/Applications/operation/saveCust
 
 DIAL setup admin can enable a schema-less application by including a JSON object with apps configurations in the DIAL Core configuration.
 
-**Important**: Apps added through direct modification of the DIAL Core configuration are immutable and cannot be edited via the UI or API, including by setup administrators. These apps are owned by the DIAL admin and are ideal for use cases where the app is configured once and remains unchanged, becoming available to users with predefined roles and limits. 
+**Important**: Apps added through direct modification of the DIAL Core configuration are immutable and cannot be edited via the UI or API, including by setup administrators. These apps are owned by the DIAL admin and are ideal for use cases where the app is configured once and remains unchanged, becoming available to users with predefined roles and permissions. 
 
 
 ## Bring Apps to DIAL
@@ -138,7 +142,8 @@ DIAL setup admin can enable a schema-less application by including a JSON object
 Following a similar pattern as for DIAL-native applications:
 
 * You can add an application type with a schema to enable end-users to create apps using UI wizards.
-* You can add a schema-less application to enable a stand-alone app with a specific configuration. Refer to [DIAL Core dynamic settings](https://github.com/epam/ai-dial-core?tab=readme-ov-file#dynamic-settings) to learn how to register your app's endpoint using `routes` to start using your app in DIAL and access all DIAL Core features.
+* You can add a schema-less application to enable a stand-alone app with a specific configuration. 
+* Refer to [DIAL Core dynamic settings](https://github.com/epam/ai-dial-core?tab=readme-ov-file#dynamic-settings) to learn how to register your app's endpoint using `routes` to start using your app in DIAL and access all DIAL Core features.
 
 
 
