The vast majority of the templates in the User Messaging category are based on the Common Response component, which enables you to use component properties and metadata to build a specialized user interface that can include text, action buttons, images, and cards.

In many of the cases, such as the templates in the Display Multimedia Messages sub-category, the main differences are in the Metadata property for the Common Response component.

In other cases, such as in the Display Tables and Forms sub-category, the template consists of a Common Response component preceded by a Set Variable component.

In the Channel-Specific Features sub-category, there are examples of using extensions available for Slack and Microsoft Teams channels.

The User Feedback component enables you to collect feedback data for Insights by presenting users with a rating scale after they've completed a transactional flow. If you're using the 21.10 SDK or later, this component outputs a horizontal star rating system. If you're using an earlier SDK, the component outputs this rating scale as a simple list that allows users to tap the button that corresponds with their rating.

While you can change the behavior of this component using the component properties, you can change its look and feel when you use the SDK (version 21.10 or later). For example, you can replace the default star icons used for the feedback buttons with another icon.

This component can return the following actions:

You can use the following system variables for the messages output by the transition states:

• system.userFeedbackRating – Returns the user's rating.
• system.userFeedbackText – When enableTextFeedback is set to true, your skill can prompt for feedback when the ratings fall below the threshold value. system.userFeedbackText returns the user's input (${system.userFeedbackText.value}).

The component's standard display text is stored in resource bundle entries. These bundle entries have default text, but you can customize them. Here are the entries for this component:

Copies values from one variable to another.

The definitions of these properties don’t have to mirror one another. While you can define both destination and source variables as lists of variables, you can also define the source variable with a single variable and the destination as a list. If you set an additional destination variable, it inherits the variable value of the proceeding source value specified.

This component resets the values of specified variables to null.

The Set Variable component sets the value of a pre-defined variable.

The Detect Language component uses the translation service to detect the user’s language from the user input.

This component sets a variable named profile.languageTag with the locale string. You can set variables with the current language when you use this variable in a value expression (${profile.languageTag}).

This component sends specified text to the skill's translation service and then stores the English translation. It relies on the skill being configured with a translation service, which recognizes the language from the user's input and translates it into in English. This component doesn't work with skills that use the Natively Supported language mode.

Use this component when you need to process the raw input text before having it translated. For example, you might want to remove some personal data from the user input before sending it to the translation service.

Because this component leverages the translation service, which already detects the user’s language, this component doesn’t need to follow states that detect or set the language.

The Translate Output component allows you to translate specified text to the user’s language. The component takes the value defined for the Expression property. It uses the skill's translation service to translate the text into the language detected by the Detect Language component or by the profile.locale variable and then stores it in the variable specified by the Variable property.

This component doesn't work with skills that use the Natively Supported language mode.

The Match Entity component calls the Intent Engine to extract entity information from the text held by the Source Variable property. If a match exists for the variable's entity type, the variable specified by the Variable property is set with this entity value.

This component also has two predefined transitions: match and nomatch.

Use this component to obtain the authorization code for services that are secured by the authorization code grant flow, such as LinkedIn, Twitter, Google, or Microsoft. The skill’s custom components can exchange the authorization code for an access token, which they then use to invoke the end service.

The component first directs the user to the identity provider’s login page. After a successful login, the component returns the authorization code in a variable, which you use to pass the authorization code to the custom component. The custom component API must exchange the authorization code, client ID, and client secret for an OAuth user access token.

For each state that requires authorization before it can be invoked, you set its Requires Authorization setting to True. See User Authorization for the steps to set this up.

${(system.message.channelConversation.channelType=='twilio')?then('false','true')}

This component can return the following actions:

The component's standard display text is stored in resource bundle entries. These bundle entries have default text, but you can customize them. Here are the entries for this component:

See Modify a Resource Bundle Entry for the steps to change the default message for a resource bundle entry.

When the dialog engine encounters this component, the skill bot prompts the user with two links — Login and Cancel.

There are several ways to transition from this component:

• The user clicks the cancel button and the component transitions to the state that's named by the fail action.

• The user doesn't click any buttons but enters text instead. The component transitions to the state that's named by the textReceived action.

• The user clicks the login link and the channel renders the identity provider’s login page or its authentication dialog as a webview, as shown in the example below. After successful authorization, the component transitions to the state that's named by the pass action (or to the next state if there isn't a pass action), which would typically call a custom component that exchanges the authorization code for an access token.

If the test window doesn’t render the webview, cut and paste the link text into your browser.

Use this component to obtain an OAuth2 user access token (grant type Authorization Code) for resources that are secured by Oracle Identity Cloud Service (IDCS), Oracle Access Manager (OAM), Microsoft identity platform, or Google OAuth 2.0 authorization. This component completes all the steps for the 3-legged OAuth2 flow and returns the OAuth2 access token.

For each state that requires authorization before it can be invoked, you set its Requires Authorization setting to True. See User Authorization for the steps to set this up.

If you need to obtain an access token of grant type Client Credentials to access client resources, see OAuth 2.0 Client.

Before you can use this component in a skill, you must do the following tasks:

1. If it hasn't been registered already, then register the client with the identity provider as described in Identity Provider Registration.
2. Add an authentication service for the identity provider, as described in Authentication Services.

Some identity providers issue refresh tokens. When you use this component, Digital Assistant stores the refresh token for the retention period that's specified for the authentication service. The Digital Assistant backend can use the refresh token, if available, to get a new access token without the user having to sign in again.

${(system.message.channelConversation.channelType=='twilio')?then('false','true')}

This component can return the following actions:

The component's standard display text is stored in resource bundle entries. These bundle entries have default text, but you can customize them. Here are the entries for this component:

See Modify a Resource Bundle Entry for the steps to change the default message for a resource bundle entry.

When the dialog engine encounters the component, the skill bot prompts the user with two links: Get an Access Token and Cancel (you can use linkLabel and cancelLabel to change the link text).

If the user clicks the link to get an access token, it displays the identity provider’s login page or authentication dialog as specified by the authentication service. After successful login, it obtains the access token, sets the values for the variables identified by accessTokenVariableName and authenticatedUserVariableName, and then flows to the state that's named by the pass action (or to the next state if there isn't a pass action). If the user cancels, the postback action is set to fail. If the user enters text, it returns the textReceived action.

As mentioned earlier, you can set requiresAuthorization for a state to ensure that the user is authorized before invoking the state's component. If the user hasn't authorized yet, the dialog invokes the Authorize User event.

Use this component to obtain an OAuth2 access token of grant type Client Credentials. That is, you use it to get an access token that's based on the client's credentials, and not the user's name and password. You can use this component to get a token that enables access to client resources that are protected by Oracle Identity Cloud Service or Oracle Access Manager (OAM).

If you need to access resources on behalf of a user, see OAuth 2.0 Account Link and OAuth Account Link.

Before you can use this component in a skill, you must do the following tasks:

1. If it hasn't been registered already, then register the client with the identity provider as described in Identity Provider Registration.
2. Add a client-credentials authentication service for the identity provider, as described in Authentication Services.

This component doesn't have any actions. To handle system problems that might occur, add a next transition that goes to a state that can handle such errors.

Use this component to revoke all the logged-in user's refresh and user access tokens from the identity provider that the authentication service represents. It also removes the refresh tokens from the database. To use this component, you must provide the identity provider's revoke refresh token URL in the Authentication Service UI.

The skill must include a state that uses the OAuth 2.0 Account Link component for the same authentication service, and it must be invoked before the state that uses this component.

This component can return the following action:

Use this component to switch states based on a variable value.

This component determines an execution path by resolving a variable or expression and then triggering a corresponding transition action that is mapped to a state in the flow.

You define and map the transition actions on the Transitions tab of the property inspector.

With this component, you call a child flow from the current flow, optionally passing in input parameters. When the child flow completes, it returns an action and optional output parameters to its parent flow.

The transition actions that can be set depend on the actions that are set in the child flow's End Flow component.

With this component, you call a different skill's flow, optionally passing in input parameters. When the called flow completes, it returns an action and optional output parameters to the calling flow.

Before you use this component, there must a public flow available in the skill you are calling. See Invoke Another Skill from a Flow.

ParamName: ParamValue

This component is used to explicitly end a flow.

When this state is reached, all of the flow's variables are cleared and control is returned to the parent flow (or, if there isn't a parent flow, the Main Flow).

You don't need an End Flow state for a flow if you don't need to return parameters or actions from the flow to a parent flow or the Main Flow.

This template consists of the Agent Initiation and Agent Conversation components. You use these components together to transfer a skill's conversation to an Oracle B2C Service agent.

• The Agent Initiation component initiates the handshake with the agent-integration channel that's specified by the component's Agent Integration Channel property.
• The Agent Conversation component manages the interchange between the skill and live agent.

This template is for conversations that originate in the skill. Do not use this template for conversations that originate in Oracle B2C Service chat, as described in The Digital Assistant as Agent Framework in Action.

You use the Agent transfer component in DA-as-agent digital assistants to transfer the conversation back to the chat service. The conversation will be routed to a live agent per the chat rules that have been configured in the chat service.

This component is for conversations that originate in a service chat, as described in The Digital Assistant as Agent Framework in Action. For conversations that originate in the skill, use the Agent Communication template instead.

You can use the Agent Transfer Condition component in DA-as-agent digital assistants to determine whether agents are available and, if so, the expected wait time.

You use the component's properties to specify the transfer conditions, and it returns an action that indicates whether the conditions were met. In addition, it sets the values of the named context map variable.

Here is the structure of the value of Agent Availability Status Variable and the information stored in it:

queueId (integer, optional): The engagement queue ID,
expectedTotalWaitSeconds (integer, optional): Expected wait time in the queue in seconds
        ( -1 if there's inadequate information, zero or greater otherwise ).,
expectedWaitSeconds (integer, optional): The number representing the "ss" segment of the expected wait time of format mm:ss 
        ( -1 if there's inadequate information, zero or greater otherwise ).,
expectedWaitMinutes (integer, optional): The number representing the "mm" segment of the expected wait time of format mm:ss 
        ( -1 if there's inadequate information, zero or greater otherwise ).,
availableAgentSessions (integer, optional): Total number of sessions available across all agents.,
totalAvailableAgents (integer, optional): Total number of agents whose status is available.,
totalUnavailableAgents (integer, optional): Total number of agents whose status is unavailable.,
totalAgentsRequestingNewEngagement (integer, optional): Total number of agents who are available and have capacity.
outsideOperatingHours (boolean, optional): True if outside operating hours. False if inside operating hours.,
engagementsInQueue (integer, optional): The number of engagements currently in the queue.
sessionId (string, optional): The session ID.,
clientId (integer, optional): The client ID.

This might take {minutes, plural,
     =-1 {}
     =0 {}
     =1 {1 minute and }
     other {# minutes and }
}{seconds, plural,
     =-1 {a while}
     =0 {{minutes, plural,
          =0 {a short wait time}
          other {0 seconds}
        }}
     =1 {1 second}
     other {# seconds}
} to connect. Are you willing to wait?

Use this component to send an HTTP request to a REST endpoint that you configured in the API Services settings.

Here are the component properties:

The component returns these actions:

To learn more, see Access Backends Using the REST Service Component.

Use this component to search Oracle B2C Service Knowledge Foundation or Oracle Fusion Service Knowledge Management for information about a given search term and to display the results.

For Oracle B2C Service, the search results depend on whether the answers are public and what the access level, product, or category settings are.

Note that you must create a knowledge search service before you can use this component. See Add a Knowledge Search Service.

Here are the Knowledge Search component properties:

You use the Incident Creation template to create an incident report on a customer service site. Note that you must create a customer service integration from the Settings > Additional Services > Customer Service Integration page before you can use this component in your instance.

Use this component to access an Oracle Intelligent Advisor interview from a skill.

You must create an Intelligent Advisor service integration before you can use this component. See Add an Intelligent Advisor Service. In addition, the interview must have been deployed to the Intelligent Advisor Hub and activated on the chat service channel. The interview must be for anonymous users. You can't access interviews for portal users or agent users.

You can use the component's properties to specify the following interview settings:

• Whether to display the titles and the explanation
• The labels for the yes, no, and uncertain buttons
• The strings that the user enters to reset, go back to the previous question (undo), and exit the interview
• The text to display at the end of the interview
• How to phrase the question about whether to display the explanation
• The string the user enters to indicate they are done uploading files
• The attribute values and connector params to pass to the interview
• The project locale to use

The Webview component opens a webview within your skill, or for skills that run in a web channel, in an browser tab.

You use this component to send a notification to a user when a Cloud-based event of a type that has been registered in Oracle Digital Assistant has occurred. See External Events for information on registering event types and configuring a digital assistant to consume the event.

You use this component to externally publish a Cloud-based event of a type that has been registered in Oracle Digital Assistant. See External Events for information on registering event types and configuring a digital assistant to publishing and consuming events.

Here's an example payload that could be used as the value for the Data property:

{
    "size": "Large",
    "type": "Veggie"
}

        "system.postbackActions": {
          "small": {
            "postback": {
              "variables": {
                "size": "Small"
              },
              "system.botId": "44F2405C-F317-4A3F-8250-617F54F01EA6",
              "action": "Small",
              "system.state": "size"

At this point, the system compares the system.state property in the payload of the incoming postback action against the current state. When the two no longer match, the skill executes a transition that can, depending on how you configure your dialog flow, either honors the user's request, or denies it.

You can change the default behavior out-of-order message handling by mapping the Out-of-Order Message system transition event to an Invoke Flow component that calls a flow you have provided for handling out-of-order messages.