Application type schemas

An application type schema is a JSON schema that defines a type of application, such as Quick Apps or Code Apps. It declares the endpoints that serve every application of the type, the properties each application sets, and the editor and viewer UIs DIAL Chat shows. Users then create schema-rich applications of that type by supplying only their properties, often through a UI wizard. This reference is for platform engineers who register application types; it assumes you know Applications.

How a schema-rich application works

You register an application type schema in Core. It conforms to Core's meta-schema, https://dial.epam.com/application_type_schemas/schema#.
A user or an administrator creates an application with applicationTypeSchemaId set to the schema's $id, and applicationProperties that conform to the schema.
When the application is called, Core sends the request to the endpoint the schema declares, and adds X-DIAL-APPLICATION-ID with the application's name. When the schema asks for it, Core also adds X-DIAL-APPLICATION-PROPERTIES.
The application type service reads the properties, through the header or with the DIAL SDK, and behaves as that application.

Parameters the schema defines take precedence over the same parameters in the application entry.

Where schemas are defined

Source	Location
Config file	`applicationTypeSchemas`, an array of schemas
Configuration API	`/v1/schemas/platform/<name>`

Schemas are matched by $id. A blob replaces the file schema with the same $id. On a Configuration API write, $id is required, cannot change for an existing schema, and must be unique. When you migrate file schemas, each one is named after the last path segment of its $id.

DIAL schema properties

These dial: properties at the top level of a schema configure the application type.

Endpoints

Property	Description
`dial:applicationTypeCompletionEndpoint`	The completion endpoint of applications of this type.
`dial:applicationTypeResponsesEndpoint`	The Responses API endpoint of applications of this type.
`dial:applicationTypeConfigurationEndpoint`	The configuration endpoint.
`dial:applicationTypeRateEndpoint`	The rate endpoint.
`dial:applicationTypeTokenizeEndpoint`	The tokenize endpoint.
`dial:applicationTypeTruncatePromptEndpoint`	The truncate prompt endpoint.
`dial:applicationTypeSchemaEndpoint`	The endpoint of the application's JSON schema.

User interface

Property	Description
`dial:applicationTypeDisplayName`	The display name of the application type.
`dial:applicationTypeIconUrl`	The icon of the application type.
`dial:applicationTypeEditorUrl`	The editor UI, which lets users create and edit applications of this type.
`dial:applicationTypeViewerUrl`	The viewer UI, which replaces the standard chat UI for applications of this type.
`dial:applicationTypePlaybackSupport`	Whether the viewer supports playback.

Behavior

Property	Description
`dial:appendApplicationPropertiesHeader`	When `true`, Core adds the header with the application's properties to each proxied request.
`dial:applicationTypeInterceptors`	The application type interceptors, run for every application of this type. See Interceptors.
`dial:applicationTypeBucketCopy`	When `enabled`, files are copied from the source to the destination of the application's bucket.
`dial:applicationTypeAssistantAttachmentsInRequestSupported`	Whether applications of this type accept DIAL attachments in assistant messages. Default `false`. When `true`, DIAL Chat keeps those attachments instead of removing them.
`dial:applicationTypeRoutes`	Routes for every application of this type. Each route takes `dial:`-prefixed versions of the route fields: `dial:paths`, `dial:rewritePath`, `dial:methods`, `dial:userRoles`, `dial:upstreams`, `dial:order`, `dial:maxRetryAttempts`, `dial:permissions`, `dial:attachmentPaths`, and `dial:response`.
`dial:applicationTypeMcp`	The MCP interface of applications of this type. See MCP.

MCP

Property	Description
`dial:endpoint`	The MCP server endpoint.
`dial:transport`	The transport. Only HTTP (Streamable HTTP) is supported.
`dial:allowedTools`	Optional. When set, Core filters the server's `tools/list` response to the tools with these names. When unset, Core passes the list through.
`dial:mcpConfigDelivery`	How Core sends the application's properties to the MCP server. `META`, the default, puts them in the `params._meta.ai_dial_config` field of each MCP message. `HEADER` sends them in the `X-DIAL-APPLICATION-PROPERTIES` header, unless `dial:appendApplicationPropertiesHeader` is `false`.
`dial:forwardPerRequestKey`	Default `true`. Core sends a per-request API key in the `API-KEY` header with every MCP request, so the application can call DIAL Core APIs, such as file storage.

Property annotations

Inside the schema's properties, these annotations describe individual application properties:

Annotation	Description
`dial:file`	The value is a DIAL file; Core checks that it exists.
`dial:resource`	The value is a DIAL resource; Core checks that it exists.
`dial:meta.dial:propertyOrder`	The order of the property in the default editor UI.
`dial:meta.dial:propertyKind`	`client` when the property is available to clients, `server` when it is server-side only.

Example

{
  "applicationTypeSchemas": [
    {
      "$schema": "https://dial.epam.com/application_type_schemas/schema#",
      "$id": "https://mydial.example.com/custom_application_schemas/report_builder",
      "dial:applicationTypeDisplayName": "Report builder",
      "dial:applicationTypeEditorUrl": "https://report-builder.example.com/editor",
      "dial:applicationTypeViewerUrl": "https://report-builder.example.com/viewer",
      "dial:applicationTypeCompletionEndpoint": "http://report-builder:5000/openai/deployments/report-builder/chat/completions",
      "dial:applicationTypeInterceptors": ["pii-redaction"],
      "properties": {
        "template": {
          "type": "string",
          "dial:meta": { "dial:propertyOrder": 1, "dial:propertyKind": "client" }
        }
      },
      "required": ["template"]
    }
  ],
  "applications": {
    "weekly-sales-report": {
      "applicationTypeSchemaId": "https://mydial.example.com/custom_application_schemas/report_builder",
      "applicationProperties": { "template": "weekly-sales" },
      "displayName": "Weekly sales report"
    }
  }
}

Core serves the schemas through its API:

Endpoint	Returns
`GET /v1/application_type_schemas/meta_schema`	The meta-schema that every application type schema conforms to
`GET /v1/application_type_schemas/schemas`	The registered application type schemas
`GET /v1/application_type_schemas/schema`	One application type schema, by its ID

The meta-schema is also in the DIAL Core repository.

How a schema-rich application works​

Where schemas are defined​

DIAL schema properties​

Endpoints​

User interface​

Behavior​

MCP​

Property annotations​

Example​

Further reading​