# Events

Conversations in Rasa are represented as a sequence of events. This page lists the event types defined in Rasa Core.

**Note**  
If you are using the Rasa SDK to write custom actions in python, you need to import the events from `rasa_sdk.events`, not from `rasa.core.events`. If you are writing actions in another language, your events should be formatted like the JSON objects on this page.

## General Purpose Events

### Set a Slot
**Short**  
Event to set a slot on a tracker

**JSON**  
```json
evt = {"event": "slot", "name": "departure_airport", "value": "BER"}
```

Class_class_`rasa.core.events.`SlotSet`( _key_, _value=None_, _timestamp=None_, _metadata=None_)

Every slot has a name and a value. This event can be used to set a value for a slot on a conversation. As a side effect the `Tracker`’s slots will be updated so that `tracker.slots[key]=value`.

**Effect**  
When added to a tracker, this is the code used to update the tracker:
```python
def apply_to(self, tracker: "DialogueStateTracker") -> None:
    tracker._set_slot(self.key, self.value)
```

### Restart a conversation
**Short**  
Resets anything logged on the tracker.

**JSON**  
```json
evt = {"event": "restart"}
```

Class_class_`rasa.core.events.`Restarted`( _timestamp=None_, _metadata=None_)  
Conversation should start over & history wiped. Instead of deleting all events, this event can be used to reset the tracker's state.

**Effect**  
When added to a tracker, this is the code used to update the tracker:
```python
def apply_to(self, tracker: "DialogueStateTracker") -> None:
    from rasa.core.actions.action import (  # pytype: disable=pyi-error
        ACTION_LISTEN_NAME,
    )

tracker._reset()
    tracker.trigger_followup_action(ACTION_LISTEN_NAME)
```

### Reset all Slots
**Short**  
Resets all the slots of a conversation.

**JSON**  
```json
evt = {"event": "reset_slots"}
```

Class_class_`rasa.core.events.`AllSlotsReset`( _timestamp=None_, _metadata=None_)  
All Slots are reset to their initial values.

**Effect**  
When added to a tracker, this is the code used to update the tracker:
```python
def apply_to(self, tracker) -> None:
    tracker._reset_slots()
```

### Schedule a reminder
**Short**  
Schedule an intent to be triggered in the future.

**JSON**  
```json
evt = {
  "event": "reminder",
  "intent": "my_intent",
  "entities": {"entity1": "value1", "entity2": "value2"},
  "date_time": "2018-09-03T11:41:10.128172",
  "name": "my_reminder",
  "kill_on_user_msg": true,
}
```

Class_class_`rasa.core.events.`ReminderScheduled`( _intent_, _trigger_date_time_, _entities=None_, _name=None_, _kill_on_user_message=True_, _timestamp=None_, _metadata=None_)

**Effect**  
When added to a tracker, Rasa Core will schedule the intent (and entities) to be triggered in the future, in place of a user input.

### Cancel a reminder
**Short**  
Cancel one or more reminders.

**JSON**  
```json
evt = {
  "event": "cancel_reminder",
  "name": "my_reminder",
  "intent": "my_intent",
  "entities": [
        {"entity": "entity1", "value": "value1"},
        {"entity": "entity2", "value": "value2"}
    ],
  "date_time": "2018-09-03T11:41:10.128172",
}
```

Class_class_`rasa.core.events.`ReminderCancelled`( _name=None_, _intent=None_, _entities=None_, _timestamp=None_, _metadata=None_)

**Effect**  
When added to a tracker, Rasa Core will cancel any outstanding reminders that match the `ReminderCancelled` event.

### Pause a conversation
**Short**  
Stops the bot from responding to messages.

**JSON**  
```json
evt = {"event": "pause"}
```

Class_class_`rasa.core.events.`ConversationPaused`( _timestamp=None_, _metadata=None_)

**Effect**  
When added to a tracker, this is the code used to update the tracker:
```python
def apply_to(self, tracker) -> None:
    tracker._paused = True
```

### Resume a conversation
**Short**  
Resumes a previously paused conversation.

**JSON**  
```json
evt = {"event": "resume"}
```

Class_class_`rasa.core.events.`ConversationResumed`( _timestamp=None_, _metadata=None_)

**Effect**  
When added to a tracker, this is the code used to update the tracker:
```python
def apply_to(self, tracker) -> None:
    tracker._paused = False
```

### Force a followup action
**Short**  
Instead of predicting the next action, force the next action to be a fixed one.

**JSON**  
```json
evt = {"event": "followup", "name": "my_action"}
```

Class_class_`rasa.core.events.`FollowupAction`( _name_, _timestamp=None_, _metadata=None_)

**Effect**  
When added to a tracker, this is the code used to update the tracker:
```python
def apply_to(self, tracker: "DialogueStateTracker") -> None:
    tracker.trigger_followup_action(self.action_name)
```

## Automatically tracked events

### User sent message
**Short**  
Message a user sent to the bot.

**JSON**  
```json
evt = {
    "event": "user",
    "text": "Hey",
    "parse_data": {
        "intent": {
            "name": "greet",
            "confidence": 0.9
        },
        "entities": []
    },
    "metadata": {},
}
```

Class_class_`rasa.core.events.`UserUttered`( _text=None_, _intent=None_, _entities=None_, _parse_data=None_, _timestamp=None_, _input_channel=None_, _message_id=None_, _metadata=None_)

**Effect**  
When added to a tracker, this is the code used to update the tracker:
```python
def apply_to(self, tracker: "DialogueStateTracker") -> None:
    tracker.latest_message = self
    tracker.clear_followup_action()
```

### Bot responded message
**Short**  
Message a bot sent to the user.

**JSON**  
```json
evt = {"event": "bot", "text": "Hey there!", "data": {}}
```

Class_class_`rasa.core.events.`BotUttered`( _text=None_, _data=None_, _metadata=None_, _timestamp=None_)

**Effect**  
When added to a tracker, this is the code used to update the tracker:
```python
def apply_to(self, tracker: "DialogueStateTracker") -> None:
    tracker.latest_bot_utterance = self
```

### Undo a user message
**Short**  
Undoes all side effects that happened after the last user message.

**JSON**  
```json
evt = {"event": "rewind"}
```

Class_class_`rasa.core.events.`UserUtteranceReverted`( _timestamp=None_, _metadata=None_)

**Effect**  
When added to a tracker, this is the code used to update the tracker:
```python
def apply_to(self, tracker: "DialogueStateTracker") -> None:
    tracker._reset()
    tracker.replay_events()
```

### Undo an action
**Short**  
Undoes all side effects that happened after the last action.

**JSON**  
```json
evt = {"event": "undo"}
```

Class_class_`rasa.core.events.`ActionReverted`( _timestamp=None_, _metadata=None_)

### Log an executed action
**Short**  
Logs an action the bot executed to the conversation.

**JSON**  
```json
evt = {"event": "action", "name": "my_action"}
```

Class_class_`rasa.core.events.`ActionExecuted`( _action_name_, _policy=None_, _confidence=None_, _timestamp=None_, _metadata=None_)

**Effect**  
When added to a tracker, this is the code used to update the tracker:
```python
def apply_to(self, tracker: "DialogueStateTracker") -> None:
    tracker.set_latest_action_name(self.action_name)
    tracker.clear_followup_action()
```

### Start a new conversation session
**Short**  
Marks the beginning of a new conversation session.

**JSON**  
```json
evt = {"event": "session_started"}
```

Class_class_`rasa.core.events.`SessionStarted`( _timestamp=None_, _metadata=None_)

**Effect**  
When added to a tracker, this is the code used to update the tracker:
```python
def apply_to(self, tracker: "DialogueStateTracker") -> None:
    # noinspection PyProtectedMember
    tracker._reset()
```

👋 I can help you get started with Rasa and answer your technical questions.