Auf Befehle der Google Chat App reagieren

Auf dieser Seite wird erläutert, wie Sie Befehle als Google Chat-App einrichten und darauf reagieren.

Mit Befehlen können Nutzer wichtige Funktionen einer Chat-App entdecken und verwenden. Nur Chat-Apps können den Inhalt eines Befehls sehen. Wenn ein Nutzer beispielsweise eine Nachricht mit einem Slash-Befehl sendet, ist die Nachricht nur für den Nutzer und die Chat-App sichtbar.

Informationen dazu, ob Sie Befehle erstellen sollten und wie Sie Nutzerinteraktionen gestalten, finden Sie unter Alle Nutzeraktionen definieren.

Arten von Chat-App-Befehlen

1. Slash-Befehle:Nutzer können einen Slash-Befehl aus dem Menü auswählen oder einen Schrägstrich (/) und dann einen vordefinierten Text wie /about eingeben. Für Chat-Apps ist in der Regel Argumenttext für den Slash-Befehl erforderlich.

   Erstellen Sie einen Slash-Befehl, wenn für Ihre Chat-App zusätzliche Eingaben vom Nutzer erforderlich sind. Sie können beispielsweise einen Slash-Befehl namens /search erstellen, der ausgeführt wird, nachdem der Nutzer einen Suchbegriff wie /search receipts eingegeben hat.

2. Schnellbefehle:Nutzer verwenden Befehle, indem sie das Menü über den Antwortbereich einer Chat-Nachricht öffnen. Um einen Befehl zu verwenden, klicken sie auf Hinzufügen und wählen einen Befehl aus dem Menü aus.

   Erstellen Sie einen Schnellbefehl, wenn Ihre Chat-App dem Nutzer sofort antworten kann, ohne auf zusätzliche Eingaben zu warten. Sie können beispielsweise einen Schnellbefehl namens Zufälliges Bild erstellen, der sofort mit einem Bild antwortet.

3. Nachrichtenaktionen:Nutzer können Nachrichtenaktionen verwenden, indem sie den Mauszeiger auf eine Nachricht bewegen und auf das Dreipunkt-Menü klicken. Um einen Befehl zu verwenden, öffnen sie das Dreipunkt-Menü und wählen einen Befehl aus dem Menü aus.

   Erstellen Sie eine nachrichtenbasierte Aktion, wenn Ihre Chat-App Aktionen basierend auf dem Kontext einer Nachricht ausführen kann.

Die folgenden Bilder zeigen, wie Nutzer das Menü für Slash- und Schnellbefehle sowie Nachrichtenaktionen aufrufen:

Vorbereitung

Befehl einrichten

In diesem Abschnitt wird beschrieben, wie Sie die folgenden Schritte ausführen, um einen Befehl einzurichten:

1. Geben Sie einen Namen und eine Beschreibung für den Befehl ein.
2. Befehl in der Google Cloud Console konfigurieren
3. Optional: Befehle Einstiegsprompts zuordnen

Befehl benennen und beschreiben

Der Name eines Befehls ist das, was Nutzer eingeben oder auswählen, um die Chat-App aufzurufen. Unter dem Namen wird auch eine kurze Beschreibung angezeigt, um Nutzer weiter darüber zu informieren, wie der Befehl verwendet wird:

Beachten Sie bei der Auswahl eines Namens und einer Beschreibung für Ihren Befehl die folgenden Empfehlungen:

So benennen Sie einen Befehl:

• Verwenden Sie kurze, beschreibende und umsetzbare Wörter oder Wortgruppen, damit die Befehle für den Nutzer klar sind. Verwenden Sie beispielsweise Remind me anstelle des Namens Create a reminder.
• Verwenden Sie einen eindeutigen oder gängigen Namen für den Befehl. Wenn Ihr Befehl eine typische Interaktion oder Funktion beschreibt, können Sie einen gängigen Namen verwenden, den Nutzer kennen und erwarten, z. B. Settings oder Feedback. Verwenden Sie ansonsten eindeutige Befehlsnamen. Wenn Ihr Befehlsname mit dem anderer Chat-Apps übereinstimmt, muss der Nutzer ähnliche Befehle filtern, um Ihren Befehl zu finden und zu verwenden.

So beschreiben Sie einen Befehl:

• Halten Sie die Beschreibung kurz und klar, damit Nutzer wissen, was sie erwartet, wenn sie den Befehl verwenden.
• Informieren Sie die Nutzer, wenn es Formatierungsanforderungen für den Befehl gibt. Wenn Sie beispielsweise einen Slash-Befehl erstellen, für den Argumenttext erforderlich ist, legen Sie die Beschreibung auf Remind me to do [something] at [time] fest.
• Teilen Sie den Nutzern mit, ob die Chat-App allen Personen im Gruppenbereich antwortet oder nur dem Nutzer, der den Befehl aufruft. Für den Schnellbefehl About könnten Sie ihn beispielsweise so beschreiben: Learn about this app (Only visible to you).

Befehl in der Google Cloud Console konfigurieren

Wenn Sie einen Slash-Befehl, einen Schnellbefehl oder eine nachrichtenbasierte Aktion erstellen möchten, geben Sie Informationen zum Befehl oder zur Aktion in der Konfiguration Ihrer Chat-App für die Google Chat API an.

So konfigurieren Sie einen Befehl in der Google Chat API:

1. Klicken Sie in der Google Cloud Console auf das Menü menu > APIs und Dienste > Aktivierte APIs und Dienste > Google Chat API.

   Zur Seite „Google Chat API“

2. Klicken Sie auf Konfiguration.

3. Rufen Sie unter Verbindungseinstellungen die Trigger auf und geben Sie die Details Ihres Endpunkts an. Sie müssen diesen Trigger im nächsten Abschnitt verwenden, um auf den Befehl zu reagieren.

   1. HTTP-Endpunkt-URL: Hier können Sie eine gemeinsame HTTP-Endpunkt-URL angeben. Wenn Sie für verschiedene Trigger unterschiedliche HTTP-Endpunkte verwenden möchten, geben Sie den Endpunkt direkt im Feld App-Befehl an.
   2. Apps Script: Geben Sie die Apps Script-Deployment-ID ein. Standardmäßig wird die Funktion onAppCommand aufgerufen. Wenn Sie eine andere Apps Script-Funktion verwenden möchten, geben Sie den Namen der benutzerdefinierten Funktion im Feld App-Befehl an.

4. Klicken Sie unter Befehle auf Befehl hinzufügen.

5. Geben Sie die folgenden Informationen zum Befehl ein:

   1. Befehls-ID:Eine Zahl zwischen 1 und 1.000, die von Ihrer Chat-App verwendet wird, um den Befehl zu erkennen und eine Antwort zurückzugeben.
   2. Beschreibung:Der Text, der beschreibt, wie der Befehl verwendet und formatiert wird. Textzeilen dürfen maximal 50 Zeichen lang sein.
   3. Befehlstyp:Wählen Sie entweder Schnellbefehl, Slash-Befehl oder Nachrichtenaktion aus.
   4. Geben Sie einen Namen für den Befehl an:
      • Name des Schnellbefehls:Der Anzeigename, den Nutzer im Menü auswählen, um den Befehl aufzurufen. Kann bis zu 50 Zeichen lang sein und Sonderzeichen enthalten. Beispiel: Remind me.
      • Name des Slash-Befehls:Der Text, den Nutzer eingeben, um den Befehl in einer Nachricht aufzurufen. Muss mit einem Schrägstrich beginnen, darf nur Text enthalten und kann bis zu 50 Zeichen lang sein. Beispiel: /remindMe.
      • Name der nachrichtenbasierten Aktion:Der Anzeigename, den Nutzer im Menü auswählen, um die nachrichtenbasierte Aktion aufzurufen. Kann bis zu 50 Zeichen lang sein und Sonderzeichen enthalten. Beispiel: Remind me.

6. Optional: Ladebenachrichtigung: Eine Toast-Benachrichtigung, die dem Nutzer angezeigt wird, während die nachrichtenbasierte Aktion ausgeführt wird. Nur für Nachrichtenaktionen verfügbar, bei denen keine Dialogfelder geöffnet werden.

7. Optional: Wenn Ihre Chat-App mit einem Dialogfeld auf den Befehl reagieren soll, aktivieren Sie das Kästchen Dialogfeld öffnen.

8. Klicken Sie auf Speichern.

Der Befehl ist jetzt für die Chat-App konfiguriert.

Befehle Starter-Prompts zuordnen

Sie können Ihre Befehle als Starter-Prompts präsentieren, damit Nutzer sie als interaktive Chips sehen, wenn sie eine leere 1:1-Direktnachricht mit Ihrer Chat-App starten.

So weisen Sie einem Einstiegsprompt einen Befehl zu:

1. Achten Sie darauf, dass für Ihren Befehl keine zusätzlichen benutzerdefinierten Argumente erforderlich sind. Nur Befehle mit Keine Argumente oder Einfache Argumente werden als Startprompts unterstützt.
2. Rufen Sie in der Google Cloud Console die Seite Konfiguration der Chat API auf.
3. Klicken Sie unter Interaktive Funktionen > Starter-Prompts auf Prompt hinzufügen.
4. Legen Sie den Rang (1–3) für die Anzeigereihenfolge fest.
5. Wählen Sie unter Typauswahl die Option Eingabeaufforderung aus und wählen Sie den gewünschten Befehl aus dem Drop-down-Menü aus.
6. Klicken Sie auf Fertig und dann auf Speichern.

Auf einen Befehl reagieren

Wenn Nutzer einen Befehl verwenden, empfängt Ihre Chat-App ein Ereignisobjekt. Die Ereignisnutzlast (event.chat.appCommandPayload) enthält ein appCommandPayload-Objekt mit Details zum aufgerufenen Befehl, einschließlich der Befehls-ID und des Befehlstyps, damit Sie eine entsprechende Antwort zurückgeben können. Das Ereignisobjekt wird an den HTTP-Endpunkt oder die Apps Script-Funktion gesendet, die Sie beim Konfigurieren des App-Befehl-Triggers angegeben haben.

Auf einen Slash-Befehl oder Schnellbefehl reagieren

Der folgende Code zeigt ein Beispiel für eine Chat-App, die auf den Slash-Befehl /about mit einer Textnachricht antwortet. Um auf Slash-Befehle oder Schnellbefehle zu reagieren, verarbeitet die Chat-App Ereignisobjekte (event.chat.appCommandPayload) aus einem App-Befehl-Trigger. Wenn die Nutzlast eines Ereignisobjekts eine übereinstimmende Befehls-ID enthält, gibt die Chat-App die Aktion DataActions mit einem createMessageAction-Objekt (hostAppDataAction.chatDataAction.createMessageAction) zurück:

// The ID of the slash command "/about".
// You must use the same ID in the Google Chat API configuration.
const ABOUT_COMMAND_ID = 1;

/**
 * Handle requests from Google Workspace add on
 *
 * @param {Object} req Request sent by Google Chat
 * @param {Object} res Response to be sent back to Google Chat
 */
http('avatarApp', (req, res) => {
  const chatEvent = req.body.chat;
  let message;
  if (chatEvent.appCommandPayload) {
    message = handleAppCommand(chatEvent);
  } else {
    message = handleMessage(chatEvent);
  }
  res.send({ hostAppDataAction: { chatDataAction: { createMessageAction: {
    message: message
  }}}});
});

/**
 * Responds to an APP_COMMAND event in Google Chat.
 *
 * @param {Object} event the event object from Google Chat
 * @return the response message object.
 */
function handleAppCommand(event) {
  switch (event.appCommandPayload.appCommandMetadata.appCommandId) {
    case ABOUT_COMMAND_ID:
      return {
        text: 'The Avatar app replies to Google Chat messages.'
      };
  }
}

# The ID of the slash command "/about".
# You must use the same ID in the Google Chat API configuration.
ABOUT_COMMAND_ID = 1

@functions_framework.http
def avatar_app(req: flask.Request) -> Mapping[str, Any]:
  """Handle requests from Google Workspace add on

  Args:
    flask.Request req: the request sent by Google Chat

  Returns:
    Mapping[str, Any]: the response to be sent back to Google Chat
  """
  chat_event = req.get_json(silent=True)["chat"]
  if chat_event and "appCommandPayload" in chat_event:
    message = handle_app_command(chat_event)
  else:
    message = handle_message(chat_event)
  return { "hostAppDataAction": { "chatDataAction": { "createMessageAction": {
      "message": message
  }}}}

def handle_app_command(event: Mapping[str, Any]) -> Mapping[str, Any]:
  """Responds to an APP_COMMAND event in Google Chat.

  Args:
    Mapping[str, Any] event: the event object from Google Chat

  Returns:
    Mapping[str, Any]: the response message object.
  """
  if event["appCommandPayload"]["appCommandMetadata"]["appCommandId"] == ABOUT_COMMAND_ID:
    return {
      "text": "The Avatar app replies to Google Chat messages.",
    }
  return {}

// The ID of the slash command "/about".
// You must use the same ID in the Google Chat API configuration.
private static final int ABOUT_COMMAND_ID = 1;

private static final Gson gson = new Gson();

/**
 * Handle requests from Google Workspace add on
 * 
 * @param request the request sent by Google Chat
 * @param response the response to be sent back to Google Chat
 */
@Override
public void service(HttpRequest request, HttpResponse response) throws Exception {
  JsonObject event = gson.fromJson(request.getReader(), JsonObject.class);
  JsonObject chatEvent = event.getAsJsonObject("chat");
  Message message;
  if (chatEvent.has("appCommandPayload")) {
    message = handleAppCommand(chatEvent);
  } else {
    message = handleMessage(chatEvent);
  }
  JsonObject createMessageAction = new JsonObject();
  createMessageAction.add("message", gson.fromJson(gson.toJson(message), JsonObject.class));
  JsonObject chatDataAction = new JsonObject();
  chatDataAction.add("createMessageAction", createMessageAction);
  JsonObject hostAppDataAction = new JsonObject();
  hostAppDataAction.add("chatDataAction", chatDataAction);
  JsonObject dataActions = new JsonObject();
  dataActions.add("hostAppDataAction", hostAppDataAction);
  response.getWriter().write(gson.toJson(dataActions));
}

/**
 * Handles an APP_COMMAND event in Google Chat.
 *
 * @param event the event object from Google Chat
 * @return the response message object.
 */
private Message handleAppCommand(JsonObject event) throws Exception {
  switch (event.getAsJsonObject("appCommandPayload")
    .getAsJsonObject("appCommandMetadata").get("appCommandId").getAsInt()) {
    case ABOUT_COMMAND_ID:
      return new Message()
        .setText("The Avatar app replies to Google Chat messages.");
    default:
      return null;
  }
}

// The ID of the slash command "/about".
// You must use the same ID in the Google Chat API configuration.
const ABOUT_COMMAND_ID = 1;

/**
 * Responds to an APP_COMMAND event in Google Chat.
 *
 * @param {Object} event the event object from Google Chat
 */
function onAppCommand(event) {
  // Executes the app command logic based on ID.
  switch (event.chat.appCommandPayload.appCommandMetadata.appCommandId) {
    case ABOUT_COMMAND_ID:
      return { hostAppDataAction: { chatDataAction: { createMessageAction: { message: {
        text: 'The Avatar app replies to Google Chat messages.'
      }}}}};
  }
}

Ersetzen Sie ABOUT_COMMAND_ID in diesem Codebeispiel durch die Befehls-ID, die Sie beim Konfigurieren des Befehls in der Chat API angegeben haben.

Auf eine nachrichtenbasierte Aktion reagieren

Der folgende Code zeigt ein Beispiel für eine Chat-App, die mit einer Textnachricht auf die nachrichtenbasierte Aktion Remind me (Erinnere mich) antwortet. Um auf Nachrichtenaktionen zu reagieren, verarbeitet die Chat App Ereignisobjekte aus einem App-Befehl-Trigger. Wenn die Nutzlast eines Ereignisobjekts eine ID für einen Befehl für eine Nachrichtenaktion enthält, gibt die Chat-App die Aktion DataActions mit einem createMessageAction-Objekt zurück:

/**
 * Responds to an APP_COMMAND interaction event from Google Chat.
 *
 * @param {Object} event The interaction event from Google Chat.
 * @param {Object} res The HTTP response object.
 * @return {Object} The JSON response message with a confirmation.
 */
function onAppCommand(event, res) {
  // Collect the command ID and type from the event metadata.
  const {appCommandId, appCommandType} =
    event.chat.appCommandPayload.appCommandMetadata;

  if (appCommandType === 'MESSAGE_ACTION' &&
      appCommandId === REMIND_ME_COMMAND_ID) {

    // Message actions can access the context of the message they were
    // invoked on, such as the text or sender of that message.
    const messageText = event.chat.appCommandPayload.message.text;

    // Return a response that includes details from the original message.
    return res.json({
      "hostAppDataAction": {
        "chatDataAction": {
          "createMessageAction": {
            "message": {
              "text": `Setting a reminder for message: "${messageText}"`
            }
          }
        }
      }
    });
  }
}

def on_app_command(event):
    """Responds to an APP_COMMAND interaction event from Google Chat.

    Args:
        event (dict): The interaction event from Google Chat.

    Returns:
        dict: The JSON response message with a confirmation.
    """
    # Collect the command ID and type from the event metadata.
    payload = event.get('chat', {}).get('appCommandPayload', {})
    metadata = payload.get('appCommandMetadata', {})
    if metadata.get('appCommandType') == 'MESSAGE_ACTION' and \
       metadata.get('appCommandId') == REMIND_ME_COMMAND_ID:

        # Message actions can access the context of the message they were
        # invoked on, such as the text or sender of that message.
        message_text = payload.get('message', {}).get('text')

        # Return a response that includes details from the original message.
        return {
            "hostAppDataAction": {
                "chatDataAction": {
                    "createMessageAction": {
                        "message": {
                            "text": f'Setting a reminder for message: "{message_text}"'
                        }
                    }
                }
            }
        }

/**
 * Responds to an APP_COMMAND interaction event from Google Chat.
 *
 * @param event The interaction event from Google Chat.
 * @param response The HTTP response object.
 */
void onAppCommand(JsonObject event, HttpResponse response) throws Exception {
  // Collect the command ID and type from the event metadata.
  JsonObject payload = event.getAsJsonObject("chat").getAsJsonObject("appCommandPayload");
  JsonObject metadata = payload.getAsJsonObject("appCommandMetadata");
  String appCommandType = metadata.get("appCommandType").getAsString();

  if (appCommandType.equals("MESSAGE_ACTION")) {
    int commandId = metadata.get("appCommandId").getAsInt();
    if (commandId == REMIND_ME_COMMAND_ID) {
      // Message actions can access the context of the message they were
      // invoked on, such as the text or sender of that message.
      String messageText = payload.getAsJsonObject("message").get("text").getAsString();

      // Return a response that includes details from the original message.
      JsonObject responseMessage = new JsonObject();
      responseMessage.addProperty("text", "Setting a reminder for message: " + messageText);

      JsonObject createMessageAction = new JsonObject();
      createMessageAction.add("message", responseMessage);

      JsonObject chatDataAction = new JsonObject();
      chatDataAction.add("createMessageAction", createMessageAction);

      JsonObject hostAppDataAction = new JsonObject();
      hostAppDataAction.add("chatDataAction", chatDataAction);

      JsonObject finalResponse = new JsonObject();
      finalResponse.add("hostAppDataAction", hostAppDataAction);

      response.getWriter().write(finalResponse.toString());
    }
  }
}

/**
 * Responds to an APP_COMMAND interaction event in Google Chat.
 *
 * @param {Object} event The interaction event from Google Chat.
 * @return {Object} The JSON response message with a confirmation.
 */
function onAppCommand(event) {
  // Collect the command ID and type from the event metadata.
  const {appCommandId, appCommandType} =
    event.chat.appCommandPayload.appCommandMetadata;

  if (appCommandType === 'MESSAGE_ACTION' &&
      appCommandId === REMIND_ME_COMMAND_ID) {

    // Message actions can access the context of the message they were
    // invoked on, such as the text or sender of that message.
    const messageText = event.chat.appCommandPayload.message.text;

    // Return a response that includes details from the original message.
    return CardService.newChatResponseBuilder()
        .setText("Setting a reminder for message: " + messageText)
        .build();
  }
}

Wenn Sie dieses Codebeispiel verwenden möchten, ersetzen Sie REMIND_ME_COMMAND_ID durch die Befehls-ID, die Sie beim Konfigurieren des Befehls in der Chat API angegeben haben.

Befehl testen

Informationen zum Testen des Befehls und des Codes finden Sie unter Interaktive Funktionen für Google Chat-Apps testen.

Informationen zum Testen und Verwenden des Befehls in der Chat-Benutzeroberfläche finden Sie in der Google Chat-Hilfe unter Apps in Google Chat verwenden.

Weitere Informationen

• Chat-App-Beispiele mit Befehlen ansehen
• Nachricht senden
• Interaktive Dialogfelder öffnen

/**
 * Handles slash and quick commands.
 *
 * @param {Object} event - The Google Chat event.
 * @param {Object} res - The HTTP response object.
 */
function handleAppCommands(event, res) {
  const {appCommandId, appCommandType} = event.appCommandMetadata;

  switch (appCommandId) {
    case ABOUT_COMMAND_ID:
      return res.send({
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      });
    case HELP_COMMAND_ID:
      return res.send({
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      });
  }
}

// Checks for the presence of a slash command in the message.
if (event.message.slashCommand) {
  // Executes the slash command logic based on its ID.
  // Slash command IDs are set in the Google Chat API configuration.
  switch (event.message.slashCommand.commandId) {
    case ABOUT_COMMAND_ID:
      return {
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      };
  }
}

def handle_app_commands(event: Mapping[str, Any]) -> Mapping[str, Any]:
    """Handles slash and quick commands.

    Args:
        Mapping[str, Any] event: The Google Chat event.

    Returns:
        Mapping[str, Any]: the response
    """
    app_command_id = event["appCommandMetadata"]["appCommandId"]

    if app_command_id == ABOUT_COMMAND_ID:
        return {
            "privateMessageViewer": event["user"],
            "text": "The Avatar app replies to Google Chat messages.",
        }
    elif app_command_id == HELP_COMMAND_ID:
        return {
            "privateMessageViewer": event["user"],
            "text": "The Avatar app replies to Google Chat messages.",
        }
    return {}

/**
 * Handles slash and quick commands.
 *
 * @param event    The Google Chat event.
 * @param response The HTTP response object.
 */
private void handleAppCommands(JsonObject event, HttpResponse response) throws Exception {
  int appCommandId = event.getAsJsonObject("appCommandMetadata").get("appCommandId").getAsInt();

  switch (appCommandId) {
    case ABOUT_COMMAND_ID:
      Message aboutMessage = new Message();
      aboutMessage.setText("The Avatar app replies to Google Chat messages.");
      aboutMessage.setPrivateMessageViewer(new User()
          .setName(event.getAsJsonObject("user").get("name").getAsString()));
      response.getWriter().write(gson.toJson(aboutMessage));
      return;
    case HELP_COMMAND_ID:
      Message helpMessage = new Message();
      helpMessage.setText("The Avatar app replies to Google Chat messages.");
      helpMessage.setPrivateMessageViewer(new User()
          .setName(event.getAsJsonObject("user").get("name").getAsString()));
      response.getWriter().write(gson.toJson(helpMessage));
      return;
  }
}

/**
 * Handles slash and quick commands.
 *
 * @param {Object} event - The Google Chat event.
 * @param {Object} res - The HTTP response object.
 */
function handleAppCommands(event, res) {
  const {appCommandId, appCommandType} = event.appCommandMetadata;

  switch (appCommandId) {
    case ABOUT_COMMAND_ID:
      return res.send({
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      });
    case HELP_COMMAND_ID:
      return res.send({
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      });
  }
}

/**
 * Handles the APP_COMMAND event type. This function is triggered when a user
 * interacts with a quick command within the Google Chat app.  It responds
 * based on the command ID.
 *
 * @param {Object} event The event object from Google Chat, containing details
 *     about the app command interaction.  It includes information like the
 *     command ID and the user who triggered it.
 */
function onAppCommand(event) {
  // Executes the quick command logic based on its ID.
  // Command IDs are set in the Google Chat API configuration.
  switch (event.appCommandMetadata.appCommandId) {
    case HELP_COMMAND_ID:
      return {
        privateMessageViewer: event.user,
        text: 'The Avatar app replies to Google Chat messages.'
      };
  }
}

def handle_app_commands(event: Mapping[str, Any]) -> Mapping[str, Any]:
    """Handles slash and quick commands.

    Args:
        Mapping[str, Any] event: The Google Chat event.

    Returns:
        Mapping[str, Any]: the response
    """
    app_command_id = event["appCommandMetadata"]["appCommandId"]

    if app_command_id == ABOUT_COMMAND_ID:
        return {
            "privateMessageViewer": event["user"],
            "text": "The Avatar app replies to Google Chat messages.",
        }
    elif app_command_id == HELP_COMMAND_ID:
        return {
            "privateMessageViewer": event["user"],
            "text": "The Avatar app replies to Google Chat messages.",
        }
    return {}

/**
 * Handles slash and quick commands.
 *
 * @param event    The Google Chat event.
 * @param response The HTTP response object.
 */
private void handleAppCommands(JsonObject event, HttpResponse response) throws Exception {
  int appCommandId = event.getAsJsonObject("appCommandMetadata").get("appCommandId").getAsInt();

  switch (appCommandId) {
    case ABOUT_COMMAND_ID:
      Message aboutMessage = new Message();
      aboutMessage.setText("The Avatar app replies to Google Chat messages.");
      aboutMessage.setPrivateMessageViewer(new User()
          .setName(event.getAsJsonObject("user").get("name").getAsString()));
      response.getWriter().write(gson.toJson(aboutMessage));
      return;
    case HELP_COMMAND_ID:
      Message helpMessage = new Message();
      helpMessage.setText("The Avatar app replies to Google Chat messages.");
      helpMessage.setPrivateMessageViewer(new User()
          .setName(event.getAsJsonObject("user").get("name").getAsString()));
      response.getWriter().write(gson.toJson(helpMessage));
      return;
  }
}

/**
 * Responds to an APP_COMMAND interaction event from Google Chat.
 *
 * @param {Object} event The interaction event from Google Chat.
 * @param {Object} res The HTTP response object.
 * @return {Object} The JSON response message with a confirmation.
 */
function handleAppCommand(event, res) {
  // Collect the command ID and type from the event metadata.
  const {appCommandId, appCommandType} = event.appCommandMetadata;

  // Use appCommandType to detect message actions.
  if (appCommandType === 'MESSAGE_ACTION' &&
      appCommandId === REMIND_ME_COMMAND_ID) {

    // Message actions can access the context of the message they were
    // invoked on, such as the text or sender of that message.
    const messageText = event.message.text;

    // Return a response that includes details from the original message.
    return res.send({
      text: `Setting a reminder for this message: "${messageText}"`
    });
  }
}

/**
 * Responds to an APP_COMMAND interaction event in Google Chat.
 *
 * @param {Object} event The interaction event from Google Chat.
 * @return {Object} The JSON response message with a confirmation.
 */
function onAppCommand(event) {
  // Collect the command ID and type from the event metadata.
  const {appCommandId, appCommandType} = event.appCommandMetadata;

  if (appCommandType === 'MESSAGE_ACTION' &&
      appCommandId === REMIND_ME_COMMAND_ID) {

    // Message actions can access the context of the message they were
    // invoked on, such as the text or sender of that message.
    const messageText = event.message.text;

    // Return a response that includes details from the original message.
    return { "text": "Setting a reminder for message: " + messageText };
  }
}

def handle_app_command(event):
    """Responds to an APP_COMMAND interaction event from Google Chat.

    Args:
        event (dict): The interaction event from Google Chat.

    Returns:
        dict: The JSON response message with a confirmation.
    """
    # Collect the command ID and type from the event metadata.
    metadata = event.get('appCommandMetadata', {})
    if metadata.get('appCommandType') == 'MESSAGE_ACTION' and \
       metadata.get('appCommandId') == REMIND_ME_COMMAND_ID:

        # Message actions can access the context of the message they were
        # invoked on, such as the text or sender of that message.
        message_text = event.get('message', {}).get('text')

        # Return a response that includes details from the original message.
        return {
            "text": f'Setting a reminder for message: "{message_text}"'
        }

/**
 * Responds to an APP_COMMAND interaction event from Google Chat.
 *
 * @param event The interaction event from Google Chat.
 * @param response The HTTP response object.
 */
void handleAppCommand(JsonObject event, HttpResponse response) throws Exception {
  // Collect the command ID and type from the event metadata.
  JsonObject metadata = event.getAsJsonObject("appCommandMetadata");
  String appCommandType = metadata.get("appCommandType").getAsString();

  if (appCommandType.equals("MESSAGE_ACTION")) {
    int commandId = metadata.get("appCommandId").getAsInt();
    if (commandId == REMIND_ME_COMMAND_ID) {
      // Message actions can access the context of the message they were
      // invoked on, such as the text or sender of that message.
      String messageText = event.getAsJsonObject("message").get("text").getAsString();

      // Return a response that includes details from the original message.
      JsonObject responseMessage = new JsonObject();
      responseMessage.addProperty("text", "Setting a reminder for message: " + messageText);
      response.getWriter().write(responseMessage.toString());
    }
  }
}