Uh oh! We couldn’t find any match.

Please try other search keywords.

Bixby Developer Center

Guides

Dialog Fragments

The following dialog fragments are available when you add custom dialog to your capsule:

Concept Fragment

Use concept fragments to talk about concepts in an abstract way, irrelevant of their instantiated value. For example, consider the sentence “There are 2 cats, a grumpy old one called Pixie and a young troublemaker called Midna”. The subject of this sentence is referred to as the concept "cats". Almost every model should define a basic concept dialog, because it will be used as a building block for numerous other dialogs. Remember to account for singular and plural differences.

This first example defines a basic concept Dialog for restaurants:

dialog (Concept) {
match: viv.restaurant.Restaurant (this)
switch (plural(this)) {
case (One) {
template(restaurant) //singular
} default {
template(restaurants) //plural
}
}
}

This second example uses a more specific match-pattern to talk about the restaurants that were found after performing a search action using from-output. It reuses the simpler concept defined in the first example, ties in some contextual information about the search inputs, and includes some expressional language.

dialog (Concept) {
match: viv.restaurant.Restaurant (this) {
from-output: restaurant.FindRestaurants (action)
}
choose(First){
if(exists(action.restaurantStyle)) {
// ex: gluten-free bakeries in San Francisco
// ex: French bistros called "Chez Maman"
template ("[#{joinAs('input', action.diet, action.allergy, action.cuisineStyle)} ]#{value(plural(action.restaurantStyle, plural(this)))}[ #{joinAs('input', action.name, action.searchRegion)}]")
} else{
// ex: Moroccan restaurant in Montreal
template ("[#{joinAs('input', action.diet, action.allergy, action.cuisineStyle)} ]#{concept(this)}[ #{joinAs('input', action.name, action.searchRegion)}]")
}
}
}

By default, when cardinality is One and execution state is Post, the default template for this dialog fragment is simply the concept name, translated from camel-case. When the concept refers to a group, the default dialog fragment is the concatenation of all the concepts in the group.

For more information on the various execution states and concept features, see the Introduction to Dialog topic.

Value Fragment

A Value fragment is a concrete instantiation of a concept. For example, consider the sentence “There are 2 pizzas: one Margarita and one Pepperoni”. The concept is “pizzas” and “Margarita” and “Pepperoni” are Value names to describe them. Primitives are easily converted into a Value. By default, they are simply dereferenced. You can decide to customize those values even more with special formatting or different phrasing. Once the primitive values are in place, they are used to define Structure Values. For Structures, it is convenient to pick a combination of properties that makes a good summary. Generally, the "name" property is sufficient.

This fragment will replace a Boolean (true, false) with a user-friendly descriptor:

dialog (Value) {
match: viv.event.IsFree (isFree)
if (isFree) {
template ("free")
}
else {
template ("priced")
}
}

This fragment customizes Enum values to take into account quantity.

dialog (Value) {
match : viv.event.EventType (this)
switch (this) {
case (Class){
switch (plural(this)) {
case (One) {
template (class)
} default {
template (classes)
}
}
}
...
}
}

This fragment refers to the event by its name.

dialog (Value) {
match: viv.event.Event (this)
// The Monster Ball Tour
template ("#{value(this.name)}")
}

This will refer to a set of events based on how they are grouped.

dialog (Value) {
match: viv.event.EventSet (this)
if (this.label == 'EventsByPerformer' && exists(this.performer)) {
// concerts by Lady Gaga
template ("#{concept(this.events)}[ #{input(performer)}]")
}
else-if (this.label == 'EventsAtVenue' && exists(this.venue)) {
// games at the Avaya Stadium
template ("#{concept(this.events)}[ #{input(venue)}]")
}
else-if (this.label == 'SingleEvent') {
// The Lion King
template ("#{value(this.events[0])}")
}
}

Structure Value Fragments

Structure values have no default fragment templates. However, you can implement a value fragment dialog for any structure. This is handy if you want to treat a composite structure as if it were a primitive, for example money.Price.

Here is an example of a simple structure value fragment:

template (Value) {
match: this(viv.money.Price)
template ("#{raw (this.currencyType.prefixSymbol)}#{number (this.value)}")
}

You can test this by paraphrasing a simple intent that has a pre-filled goal:

intent {
goal: viv.money.Price {
value: viv.money.CurrencyValue (4.21)
currencyType:money.CurrencyType { currencyCode: (USD) }
}
}

This would work with the following utterance: Hey Bixby, find $4.21.

While this dialog would work for most cases, it doesn't take into account negative values or decimal values with improper precision. Consider the following intent:

intent {
goal: viv.money.Price {
value: viv.money.CurrencyValue (-4.3)
currencyType:viv.money.CurrencyType { currencyCode: (USD) }
}
}

This utterance is less ideal because of the strange formatting: Hey Bixby, find $-4.3.

You should enhance it to improve rendering of negative prices and fix the precision formatting.

template (Value) {
match: this (viv.money.Price)
if (value >= 0.0) {
template ("#{value (this.currencyType.prefixSymbol)}#{number (this.value, '#,##0.00')}")
}
else-if (value < 0.0) {
template ("-#{value (this.currencyType.prefixSymbol)}#{number(-1.0 * this.value, '#,##0.00')}")
}
}

The above dialog fragment handles all possible variations, creating an ideal formatting for utterances: Hey Bixby, find -$4.30.

Input Fragment

Input fragments describe the concrete instantiation of an action parameter. They generally start with a preposition followed by a value.

Here are a couple of examples that cover cases where the user searches for a hotel amenity:

Example 1:

dialog (Input) {
match: viv.hotel.HotelAmenity (this)
// with beach access
template ("with #{value (this)}")
}

Example dialog: with beach access

Example 2:

dialog (Input) {
match: viv.air.DepartureAirport (this) {
to-input: _
}
switch(plural(this)) {
case (One) {
template ("from #{value (this)}")
}
default {
template("#{value (this.locality.name)}")
}
}
}

Example dialog: from SFO

Action Fragment

An action fragment describes the state of an action using a verb phrase, normally while using execution states to differentiate between the different phases.

As with other fragment types, if a fragment yields multiple templates, the system will choose one at random.

When an action fragment refers to a noun, as in Example 1, it delegates to a concept fragment.

Here are some examples:

Example 1:

dialog (Action) {
match {
viv.cart.PutShippingOption (action)
}
switch (state(action)) {
case (Pre) {
template ("set #{concept(action.shippingOption)}")
}
case (Mid) {
template ("setting #{concept(action.shippingOption)}")
}
case (Post) {
template ("set #{concept(action.shippingOption)}")
}
}
}

Example dialog:

  • set shipping option
  • setting shipping option
  • set shipping option

Example 2:

dialog (Action) {
match: phone.PhoneCallReceipt {
from-output: phone.Call (this)
}
switch (state(this)) {
case (Pre) {
template ("call[ #{value (this.phoneNumber)}]")
template ("make a phone call[ to #{value (this.phoneNumber)}]")
}
case (Mid) {
template ("calling[ #{value (this.phoneNumber)}]")
template ("making a phone call[ to #{value (this.phoneNumber)}]")
}
case (Post) {
template ("called[ #{value (this.phoneNumber)}]")
}
}
}

Example dialog:

  • call 408-123-4567
  • calling 408-123-4567
  • called 408-123-4567