vania-janet/multiturn-rag-retrieval-data huggingface dataset:
For example, you might want to first check whether the input contains an intent, such as turn_on, and if it does, you might want to check whether the input contains entities, such as @lights, @radio, or @wipers. Chaining conditions helps to structure larger dialog trees.

Avoid choosing this option when configuring a jump-to from a conditional response that goes to a node situated before the current node in the dialog tree. Otherwise, you can create an infinite loop. If your assistant jumps to the earlier node and checks its condition, it is likely to return false because the same user input is being evaluated that triggered the current node last time through the dialog. Your assistant will go to the next sibling or back to root to check the conditions on those nodes, and will likely end up triggering this node again, which means the process will repeat itself.
* Response: If the statement targets the response section of the selected dialog node, it is run immediately. That is, the system does not evaluate the condition of the selected dialog node; it processes the response of the selected dialog node immediately.

Targeting the response is useful for chaining several dialog nodes together. The response is processed as if the condition of this dialog node is true. If the selected dialog node has another Jump to action, that action is run immediately, too.
* Wait for user input: Waits for new input from the user, and then begins to process it from the node that you jump to. This option is useful if the source node asks a question, for example, and you want to jump to a separate node to process the user's answer to the question.









 Next steps 



* Be sure to test your dialog as you build it. For more information, see [Testing the dialog](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-dialog-tasks).
* For more information about ways to address common use cases, see [Dialog building tips](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-dialog-tips).
v1 [cURL](https://cloud.ibm.com/apidocs/assistant/assistant-v1updatedialognode)[node](https://cloud.ibm.com/apidocs/assistant/assistant-v1?code=nodeupdatedialognode)[java](https://cloud.ibm.com/apidocs/assistant/assistant-v1?code=javaupdatedialognode)[python](https://cloud.ibm.com/apidocs/assistant/assistant-v1?code=pythonupdatedialognode) 
 Delete dialog node Delete a dialog node from a workspace. v1 [cURL](https://cloud.ibm.com/apidocs/assistant/assistant-v1deletedialognode)[node](https://cloud.ibm.com/apidocs/assistant/assistant-v1?code=nodedeletedialognode)[java](https://cloud.ibm.com/apidocs/assistant/assistant-v1?code=javadeletedialognode)[python](https://cloud.ibm.com/apidocs/assistant/assistant-v1?code=pythondeletedialognode) 
 List log events in a workspace List the events from the log of a specific workspace. v1 [cURL](https://cloud.ibm.com/apidocs/assistant/assistant-v1listlogs)[node](https://cloud.ibm.com/apidocs/assistant/assistant-v1?code=nodelistlogs)[java](https://cloud.ibm.com/apidocs/assistant/assistant-v1?code=javalistlogs)[python](https://cloud.ibm.com/apidocs/assistant/assistant-v1?code=pythonlistlogs) 
 List log events in all workspaces List the events from the logs of all workspaces in the service instance.
If you use the 2017-05-26 API to import a workspace that was exported using an earlier version, some dialog nodes might not import correctly. For best results, always import a workspace using the same version that was used to export it.







 25 May 2017 

Manage context variables
: You can now manage context variables in the "Try it out" pane. Click the Manage context link to open a new pane where you can set and check the values of context variables as you test the dialog. See [Testing your dialog](https://cloud.ibm.com/docs/assistant?topic=assistant-dialog-tasksdialog-tasks-test) for more information.





 16 May 2017 

Updates
: This release includes the following updates:



* A Car Dashboard sample workspace is now available when you open the tool. To use the sample as a starting point for your own workspace, edit the workspace. If you want to use it for multiple workspaces, then duplicate it instead. The sample workspace does not count toward your subscription workspace total unless you use it.
* It is now easier to navigate the tool. The navigation menu options are available from the side of the main page instead of the top. In the page header, breadcrumb links display that show you where you are. You can now switch between service instances from the Workspaces page. To get there quickly, click Back to workspaces from the navigation menu. If you have multiple service instances, the name of the current instance is displayed. You can click the Change link beside it to choose another instance.
* When you create a dialog, two nodes are now added to it for you: 1) a Welcome node at the start the dialog tree that contains the greeting to display to the user and 2) an Anything else node at the end of the tree that catches any user inquiries that are not recognized by other nodes in the dialog and responds to them. See [Creating a dialog](https://cloud.ibm.com/docs/assistant?topic=assistant-dialog-build) for more details.
For an example of implementing option responses in a simple client application, see [Example: Implementing option responses](https://cloud.ibm.com/docs/assistant?topic=assistant-api-dialog-responsesapi-dialog-option-example).





 Suggestion 

This feature is available only to users with a paid plan.

The suggestion response type is used by the disambiguation feature to suggest possible matches when it isn't clear what the user wants to do. A suggestion response includes an array of suggestions, each one corresponding to a possible matching dialog node:

{
"output": {
"generic": [
{
"response_type": "suggestion",
"title": "Did you mean:",
"suggestions":
{
"label": "I'd like to order a drink.",
"value": {
"intents":
{
"intent": "order_drink",
"confidence": 0.7330395221710206
}
],
"entities": ],
"input": {
"suggestion_id": "576aba3c-85b9-411a-8032-28af2ba95b13",
"text": "I want to place an order"
}
},
"output": {
"text":
"I'll get you a drink."
],
"generic":
{
"response_type": "text",
"text": "I'll get you a drink."
}
],
"nodes_visited_details":
{
"dialog_node": "node_1_1547675028546",
"title": "order drink",
"user_label": "I'd like to order a drink.",
"conditions": "order_drink"
}
]
},
"source_dialog_node": "root"
},
* [Adding Connect to human agent response type](https://cloud.ibm.com/docs/assistant?topic=assistant-dialog-overviewdialog-overview-add-connect-to-human-agent) (dialog node)
* [Deciding what to do next](https://cloud.ibm.com/docs/assistant?topic=assistant-actionsactions-what-next) (action step)



The phone integration supports additional parameters for the Connect to human agent response type. You can add these phone-specific parameters to the connect_to_agent response type using the JSON editor.

The connect_to_agent response type supports the ability to specify the target transfer information under the transfer_info parameter.

The following example shows a transfer that uses all of the configurable parameters:

{
"output": {
"generic": [
{
"response_type": "connect_to_agent",
"transfer_info": {
"target": {
"service_desk": {
"sip": {
"uri": "sip:user\@domain.com",
"transfer_headers":
{
"name": "Customer-Header1",
"value": "Some-Custom-Info"
},
{
"name": "User-to-User",
"value": "XXXXXX"
}
],
"transfer_headers_send_method": "refer_to_header"
}
}
}
},
"agent_available": {
"message": "I'll transfer you to an agent"
},
"agent_unavailable": {
"message": "Sorry, I could not find an agent."
},
"message_to_human_agent": "The caller needs help resetting their password"
}
]
}
}
Show more

The connect_to_agent response type supports the following phone-specific properties.



 Parameter Default Description
If the user says no, then the user is returned to the flow that was interrupted.







 Disabling digressions into a root node 

When a flow digresses into a root node, it follows the course of the dialog that is configured for that node. So, it might process a series of child nodes before it reaches the end of the node branch, and then, if configured to do so, goes back to the dialog flow that was interrupted. Through dialog testing, you might find that a root node is triggered too often, or at unexpected times, or that its dialog is too complex and leads the user too far off course to be a good candidate for a temporary digression. If you determine that you would rather not allow users to digress into it, you can configure the root node to not allow digressions in.

To disable digressions into a root node altogether, complete the following steps:



1. Click to open the root node that you want to edit.
2. Click Customize, and then click the Digressions tab.
3. Set the Allow digressions into this node toggle to Off.
4. Click Apply.



If you decide that you want to prevent digressions into several root nodes, but do not want to edit each one individually, you can add the nodes to a folder. From the Customize page of the folder, you can set the Allow digressions into this node toggle to Off to apply the configuration to all of the nodes at once. See [Organizing the dialog with folders](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-dialog-tasksdialog-tasks-folders) for more information.





 Digression tutorial 

Follow the [tutorial](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-tutorial-digressions) to import a workspace that has a set of nodes already defined. You can walk through some exercises that illustrate how digressions work.





 Design considerations
This documentation is for the classic Watson Assistant experience. To see the documentation for the new Watson Assistant, please go [here](https://cloud.ibm.com/docs/watson-assistant).



 Defining responses using the JSON editor 

In some situations, you might need to define responses using the JSON editor. (For more information about dialog responses, see [Responses](https://cloud.ibm.com/docs/assistant?topic=assistant-dialog-overviewdialog-overview-responses)). Editing the response JSON gives you direct access to the data that will be returned to the integration or custom client.



 Generic JSON format 

The generic JSON format for responses is used to specify responses that are intended for any integration or custom client. This format can accommodate various response types that are supported by multiple integrations, and can also be implemented by a custom client application. (This is the format that is used by default for dialog responses defined using the Watson Assistant tool.)

You can also specify responses using the native format used by the target channel. For more information, see [Native JSON format](https://cloud.ibm.com/docs/assistant?topic=assistant-dialog-responses-jsondialog-responses-json-native).

For information about how to open the JSON editor for a dialog node response from the tool, see [Context variables in the JSON editor](https://cloud.ibm.com/docs/assistant?topic=assistant-dialog-runtime-contextdialog-runtime-context-var-json).

To specify an interactive response in the generic JSON format, insert the appropriate JSON objects into the output.generic field of the dialog node response. The following example shows how you might send a response containing multiple response types (text, an image, and clickable options):

{
"output": {
"generic":[
{
"response_type": "text",
"values":
{
"text": "Here are your nearest stores."
}
]
},
{
"response_type": "image",
Use a condition, such as $isPlatinumMember, for example, to group together nodes that offer extra services that should only be processed if the current user is entitled to receive the extra services.
* To hide nodes from the runtime while you work on them. You can add the nodes to a folder with a false condition to prevent them from being processed.



These characteristics of the folder impact how the nodes in a folder are processed:



* Condition: If no condition is specified, then your assistant processes the nodes within the folder directly. If a condition is specified, your assistant first evaluates the folder condition to determine whether to process the nodes within it.
* Customizations: Any configuration settings that you apply to the folder are inherited by the nodes in the folder. If you change the digression settings of the folder, for example, the changes are inherited by all the nodes in the folder.
* Tree hierarchy: Nodes in a folder are treated as root or child nodes based on whether the folder is added to the dialog tree at the root or child level. Any root level nodes that you add to a root level folder continue to function as root nodes; they do not become child nodes of the folder, for example. However, if you move a root level node into a folder that is a child of another node, then the root node becomes a child of that other node.



Folders have no impact on the order in which nodes are evaluated. Nodes continue to be processed from first to last. As your assistant travels down the tree, when it encounters a folder, if the folder has no condition or its condition is true, it immediately processes the first node in the folder, and continues down the tree in order from there. If a folder does not have a folder condition, then the folder is transparent to your assistant, and each node in the folder is treated like any other individual node in the tree.



 Adding a folder 

To add a folder to a dialog tree, complete the following steps:



1. From the tree view of the Dialog tab, click Add folder.

The folder is added to the end of the dialog tree, just before the Anything else node. Unless an existing node in the tree is selected, in which case, it is added after the selected node.
(See [Building a dialog](https://cloud.ibm.com/docs/assistant?topic=assistant-dialog-build) for details.)



* You can add a condition to a slot to make it required only if certain conditions are met. For example, you can make a slot that asks for the name of a spouse required only if a previous (required) slot that asks for marital status indicates that the user is married.
* You can now choose Skip user input as the next step for a node. When you choose this option, after processing the current node, your assistant jumps directly to the first child node of the current node. This option is similar to the existing Jump to next step option, except that it allows for more flexibility. You do not need to specify the exact node to jump to. At run time, your assistant always jumps to whichever node is the first child node, even if the child nodes are reordered or new nodes are added after the next step behavior is defined.
* You can add conditional responses for slots. For both Found and Not found responses, you can customize how your assistant responds based on whether certain conditions are met. This feature enables you to check for possible misinterpretations and correct them before saving the value provided by the user in the slot's context variable. For example, if the slot saves the user's age, and uses @sys-number in the Check for field to capture it, you can add a condition that checks for numbers over 100, and responds with something like, Please provide a valid age in years. See [Adding conditions to Found and Not found responses](https://cloud.ibm.com/docs/assistant?topic=assistant-dialog-slotsdialog-slots-handler-next-steps) for more details.
* The interface you use to add conditional responses to a node has been redesigned to make it easier to list each condition and its response. To add node-level conditional responses, click Customize, and then enable the Multiple responses option.



The Multiple responses toggle sets the feature on or off for the node-level response only. It does not control the ability to define conditional responses for a slot. The slot multiple response setting is controlled separately.
: When you add the Connect to human agent response type to a dialog node, you can now define messages to show to your customers during the transfer, and can specify service desk agent routing preferences. For more information, see [Adding a Connect to human agent response type](https://cloud.ibm.com/docs/assistant?topic=assistant-dialog-overviewdialog-overview-add-connect-to-human-agent).





 22 September 2020 

New API version
: The current v2 API version is now 2020-09-24. In this version, the structure of the search response type has changed. The results property has been removed and replaced with two new properties:



* primary_results property includes the search results that should be displayed in the initial response to a user query.
* additional_results property includes search results that can be displayed if the user wants to see more.



The search skill configuration determines how many search results are included in the primary_results and additional_results properties.

Search skill improvements
: The following improvements were made to the search skill:



* Control the number of search results: You can now customize the number of search results that are shown in a response from the search skill. For more information, see [Configure the search](https://cloud.ibm.com/docs/assistant?topic=assistant-skill-search-addskill-search-add-configure).
* FAQ extraction is available for web crawl data collections: When you create a web crawl data collection type, you can now enable the FAQ extraction beta feature. FAQ extraction allows the Discovery service to identify question and answer pairs that it finds as it crawls the website. For more information, see [Create a data collection](https://cloud.ibm.com/docs/assistant?topic=assistant-skill-search-addskill-search-add-create-discovery-collection).







 16 September 2020 

Search skill refinement change
: The search refinement beta feature that was added in [June](https://cloud.ibm.com/docs/assistant?topic=assistant-release-notes24jun2020) now is disabled by default.
* A node cannot point to a previous sibling that is a child of a different parent.
* Two nodes cannot point to the same previous sibling.
* A node can specify another node that is to be executed next (the next_step property).
* A node cannot be its own parent or its own sibling.
* A node must have a type property that contains one of the following values. If no type property is specified, then the type is standard.



* event_handler: A handler that is defined for a frame node or an individual slot node.



From the tool, you can define a frame node handler by clicking the Manage handlers link from a node with slots. (The tool user interface does not expose the slot-level event handler, but you can define one through the API.)



* frame: A node with one or more child nodes of type slot. Any child slot nodes that are required must be filled before the service can exit the frame node.



The frame node type is represented as a node with slots in the tool. The node that contains the slots is represented as a node of type=frame. It is the parent node to each slot, which is represented as a child node of type slot.



* response_condition: A conditional response.



In the tool, you can add one or more conditional responses to a node. Each conditional response that you define is represented in the underlying JSON as an individual node of type=response_condition.



* slot: A child node of a node of type frame.



This node type is represented in the tool as being one of multiple slots added to a single node. That single node is represented in the JSON as a parent node of type frame.



* standard: A typical dialog node. This is the default type.



* For nodes of type slot that have the same parent node, the sibling order (specified by the previous_sibling property) reflects the order in which the slots will be processed.
* A node of type slot must have a parent node of type frame.
* A node of type frame must have at least one child node of type slot.
* A node of type response_condition must have a parent node of type standard or frame.
You can choose to show an indicator that the dialog is working on typing a response. Use this response type if you need to perform an action that might take some time. For example, a parent node makes a Cloud Function call and displays the result in a child node. You could use this response type as the response for the parent node to give the programmatic call time to complete, and then jump to the child node to show the result. This response type does not render in the Try it out pane. You must access a node that uses this response type from a test deployment to see how your users will experience it.
* Search skill: Searches an external data source for relevant information to return to the user. The data source that is searched is a Discovery service data collection that you configure when you add a search skill to the assistant that uses this dialog skill. For more information, see [Creating a search skill](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-skill-search-add).





 Adding rich responses 

To add a rich response, complete the following steps:



1. Click the drop-down menu in the response field to choose a response type, and then provide any required information:



* Connect to human agent. You can optionally add a message to share with the human agent to whom the conversation is transferred.

You must program the client application to recognize when this response type is triggered.
* Image. Add the full URL to the hosted image file into the Image source field. The image must be in .jpg, .gif, or .png format. The image file must be stored in a location that is publicly addressable by URL.

For example: https://www.example.com/assets/common/logo.png.

If you want to display an image title and description before the embedded image in the response, then add them in the fields provided.
* Option. Complete the following steps:



1. Click Add option.
2. In the List label field, enter the option to display in the list. The label must be less than 2,048 characters in length.
3.
: You can now call Cloud Functions web actions from a dialog node. See [Making programmatic calls from a dialog node](https://cloud.ibm.com/docs/assistant?topic=assistant-dialog-actions-client) for more details.





 15 August 2018 

Entity fuzzy matching support improvements
: Fuzzy matching is fully supported for English entities, and the misspelling feature is no longer a Beta-only feature for many other languages. See [Supported languages](https://cloud.ibm.com/docs/assistant?topic=assistant-language-support) for details.





 6 August 2018 

Intent conflict resolution
: The tool can now help you to resolve conflicts when two or more user examples in separate intents are similar to one another. Non-distinct user examples can weaken the training data and make it harder for your assistant to map user input to the appropriate intent at run time. See [Resolving intent conflicts](https://cloud.ibm.com/docs/assistant?topic=assistant-intentsintents-resolve-conflicts) for details.

Disambiguation
: Enable disambiguation to allow your assistant to ask the user for help when it needs to decide between two or more viable dialog nodes to process for a response. See [Disambiguation](https://cloud.ibm.com/docs/assistant?topic=assistant-dialog-runtimedialog-runtime-disambiguation) for more details.

Jump-to fix
: Fixed a bug in the Dialogs tool which prevented you from being able to configure a jump-to that targets the response of a node with the anything_else special condition.

Digression return message
: You can now specify text to display when the user returns to a node after a digression. The user will have seen the prompt for the node already. You can change the message slightly to let users know they are returning to where they left off. For example, specify a response like, Where were we? Oh, yes...