Custom Components

Search…
Custom Components
Custom components are clearly an advanced feature of CSML. Unless you are missing specific features with the default capabilities of standard CSML message components, you probably will never need to learn more about this topic!
Feel free to skip to the next section 😉
Introduction to CSML Component templates
Under the hood, all message components are created using a JSON-based templating system to describe how the component should behave, what properties it should accept, which are required or optional, their type, etc.
For instance, here is the low-level code to generate the simple Text() component:
1
{
2
  "params": [
3
    {
4
      "text": {
5
        "required": true,
6
        "type": "String",
7
      }
8
    }
9
  ]
10
}
Copied!
Which outputs the following JSON payload when used in a CSML flow:
1
{
2
  "content_type": "text",
3
  "content": {
4
    "text": "Hello!"
5
  }
6
}
Copied!
Obviously, more complex components are also possible. Here is an example with the standard Button() component:
1
{
2
  "params": [
3
    {
4
      "title": {
5
        "required": true,
6
        "type": "String"
7
      }
8
    },
9
    {
10
      "payload": {
11
        "required": false,
12
        "type": "String",
13
        "default_value": [
14
          {"$_get": "title"}
15
        ]
16
      }
17
    },
18
    {
19
      "accepts": {
20
        "required": false,
21
        "type": "Array",
22
        "default_value": [
23
        ],
24
        "add_value": [
25
          {"$_get": "title" },
26
          {"$_get": "payload" }
27
        ]
28
      }
29
    }
30
  ]
31
}
Copied!
You will notice the use of the $_get keyword. This function retrieves the value of the given parameter and sets if in place. So for example, in our example, the button's payload will be set to what the developers sets, or by default to the value of the title parameter. Same thing goes for the accepts property, which results in the following output:
1
// input: Button(title = "hi")
2
​
3
// output:
4
{
5
  "content_type": "button",
6
  "content": {
7
    "title": "hi",
8
    // retrieve the title by default
9
    "payload": "hi",
10
    // in this case, we are retrieving the value of `title` and the value
11
    // of `payload` which happens to be set to the value
12
    // of `title` by default and not overriden by any user value.
13
    "accepts": ["hi", "hi"]
14
  }
15
}
Copied!
Creating Custom Message Components
In addition to the standard components, you can also add your own custom message components using the same templating format.
1
{
2
  "MyComponent": {
3
    "params": [
4
      {
5
        "title": {
6
          "required": true,
7
          "type": "String",
8
        }
9
      },
10
      {
11
        "info": {
12
          "required": false,
13
          "type": "String",
14
          "default_value": [
15
            {"$_set": "this is a default message" },
16
          ]
17
        }
18
      },
19
      {
20
        "list": {
21
          "required": false,
22
          "type": "Array",
23
          "add_value": [
24
              {"$_get": "title" },
25
          ]
26
        }
27
      }
28
    ]
29
  }
30
}
Copied!
params
Each component is made of a list of params, that all have the same structure:
1
{
2
  "params": [
3
    {
4
      "param_name": {
5
        "required": Boolean,
6
        "type": Type,
7
        "default_value": Array,
8
        "add_value": Array
9
      }
10
    }
11
  ]
12
}
Copied!
required 
if set to true, will display an error when the value is not set in the flow
type
describe the type of the parameter to accept
Null
Bool
Number
String
Array
Object
default_value
default value to set on the object
1
  "default_value": [
2
      {"$_get": "title"},
3
  ]
Copied!
add_value
values to add to the object in all cases (even if a default value is set)
1
  "add_value": [
2
      {"$_set": "text" },
3
  ]
4
​
Copied!
$_get, $_set
$_get: will inject the value of the given parameter
$_set: will set the field to a specific value
Why Use Custom Components?
In some cases, you may want to specialize your chatbot for one specific channel, which has some complex formats available that you want to make easier to use. For example, CSML Studio has a QuickReply custom component, which is a quicker way to create quick replies, which are features of Messenger, Workplace Chat and the Webapp channels.
1
say MessengerQuickReply(
2
    "here are some quick replies",
3
    buttons=["btn1", "btn2", "btn3"]
4
)
5
​
6
// same output, with the standard Question component
7
say Question(
8
    "here are some quick replies",
9
    button_type="quick_reply",
10
    buttons=[Button("btn1"), Button("btn2"), Button("btn3")]
11
)
Copied!
If you are making a specialized chatbot for a specific channel, consider using custom components to make your life easier!
How to use Custom Message Components
There are two ways to import your own custom components in the CSML Engine and use them in your flows.
as native components by saving your all your custom component files in files in a given directory, and set the COMPONENTS_DIR environment variable in your CSML Engine. In that case, the name of the component will be the name of the file (without the extension).
as local components by adding a list of custom components to your chatbot's configuration when calling the engine. In that case, you should add a custom_components parameter to your bot description with an array of key/value objects where the key is the name of the component and the value its definition.
Native components and local components behave exactly as standard components. The only difference is that local components are used with a prefix  (Component.MyComponent) in your flows, whereas native components can be called directly (MyComponent). This allows you to define different components per bot for the same engine instance, while being able to use common components across all your chatbots. Similarly, local components are easier to share with other users of your chatbots as they can be packaged together.
1
// as a native component
2
start:
3
  say MyComponent("this is my custom component")
4
  goto end
5
​
6
// as local component
7
start:
8
  say Component.MyComponent("this is my custom component")
9
  goto end
10
​
11
// JSON output
12
{
13
  "content": {
14
    "title": "this is my custom component",
15
    "info": "this is a default message",
16
    "list": [
17
      "this is my custom component",
18
    ]
19
  },
20
  "content_type": "mycomponent"
21
}
Copied!
Message Payloads
The Event
Last modified 11mo ago
Export as PDF
Copy link
Contents
Introduction to CSML Component templates
Creating Custom Message Components
Why Use Custom Components?
How to use Custom Message Components