Verwenden von Dialogen in einem SkillUse dialogs within a skill

gilt für: SDK v4APPLIES TO: SDK v4

In diesem Artikel wird veranschaulicht, wie ein Skill erstellt werden kann, der mehrere Aktionen unterstützt.This article demonstrates how to create a skill that supports multiple actions. Diese Aktionen werden mithilfe von Dialogen unterstützt.It supports these actions using dialogs. Der Hauptdialog erhält die erste Eingabe vom Skillconsumer und startet dann die entsprechende Aktion.The main dialog receives the initial input from the skill consumer, and then starts the appropriate action. Informationen zur Implementierung des Skillconsumers für den zugehörigen Beispielcode finden Sie unter Verwendung eines Skills mithilfe von Dialogen.For information about implementing the skill consumer for the associated sample code, see how to consume a skill using dialogs.

Dieser Artikel setzt voraus, dass Sie bereits mit der Erstellung von Skills vertraut sind.This article assumes you are already familiar with creating skills. Informationen zum Erstellen eines Skillbots im Allgemeinen finden Sie unter Implementieren eines Skills.For how to create a skill bot in general, see how to implement a skill.

VoraussetzungenPrerequisites

Hinweis

Ab Version 4.11 benötigen Sie keine App-ID und kein Kennwort, um einen Skill lokal im Emulator zu testen.Starting with version 4.11, you do not need an app ID and password to test a skill locally in the Emulator. Ein Azure-Abonnement ist weiterhin erforderlich, um Ihre Qualifikation in Azure bereitzustellen.An Azure subscription is still required to deploy your skill to Azure.

Informationen zu diesem BeispielAbout this sample

Das Skillbeispiel skillDialog enthält Projekte für zwei Bots:The skills skillDialog sample includes projects for two bots:

  • dialog root bot, in dem mit einer skillDialog-Klasse ein Skill genutzt wird.The dialog root bot, which uses a skill dialog class to consume a skill.
  • dialog skill bot, das einen Dialog verwendet, um von Skillconsumern stammende Aktivitäten zu behandeln.The dialog skill bot, which uses a dialog to handle activities coming from skill consumers. Dieser Skill ist eine Adaption des Beispiels core bot.This skill is an adaptation of the core bot sample. (Weitere Informationen zu „core bot“ finden Sie unter Hinzufügen von Features zum Verstehen natürlicher Sprache zu Ihrem Bot.)(For more about the core bot, see how to add natural language understanding to your bot.)

Dieser Artikel konzentriert sich auf die Verwendung von Dialogen innerhalb eines Skillbots zur Abwicklung mehrerer Aktionen.This article focuses on how to use a dialogs within a skill bot to manage multiple actions.

Weitere Informationen zum Skillconsumerbot finden Sie unter Nutzen eines Skills mithilfe von Dialogen.For information about the skill consumer bot, see how to consume a skill using dialogs.

RessourcenResources

Für bereitgestellte Bots erfordert die Bot-zu-Bot-Authentifizierung, dass jeder teilnehmende Bot über eine gültige App-ID und ein gültiges Kennwort verfügt.For deployed bots, bot-to-bot authentication requires that each participating bot has a valid app ID and password. Sie können Skills und Skill-Benutzer jedoch lokal mit dem Emulator ohne App-ID und Kennwort testen.However, you can test skills and skill consumers locally with the Emulator without an app ID and password.

Um den Skill für benutzerorientierte Bots verfügbar zu machen, registrieren Sie den Skill bei Azure.To make the skill available to user-facing bots, register the skill with Azure. Sie können eine Botkanalregistrierung verwenden.You can use a Bot Channels Registration. Weitere Informationen finden Sie unter Registrieren eines Bots bei Azure Bot Service.For more information, see how to register a bot with Azure Bot Service.

Optional kann der Skillbot ein LUIS-Modell für die Flugbuchung verwenden.Optionally, the skill bot can use a flight-booking LUIS model. Um dieses Modell zu nutzen, verwenden Sie die Datei „CognitiveModels/FlightBooking.json“, um das LUIS-Modell zu erstellen, zu trainieren und zu veröffentlichen.To use this model, use the CognitiveModels/FlightBooking.json file to create, train, and publish the LUIS model.

AnwendungskonfigurationApplication configuration

  1. Fügen Sie optional die App-ID und das Kennwort des Skills zur Konfigurationsdatei des Skills hinzu.Optionally, add the skill's app ID and password to the skill's configuration file. (Wenn der Skill- oder Skill-Consumer eine App-ID und ein Kennwort verwendet, müssen beides erforderlich sein.)(If either the skill or skill consumer uses an app ID and password, both must.)

  2. Wenn Sie das LUIS-Modell verwenden, fügen Sie LUIS-App-ID, den API-Schlüssel und den API-Hostnamen hinzu.If you are using the LUIS model, Add the LUIS app ID, API key, and API host name.

DialogSkillBot\appsettings.jsonDialogSkillBot\appsettings.json

{
  "MicrosoftAppId": "",
  "MicrosoftAppPassword": "",
  "ConnectionName": "",

  "LuisAppId": "",
  "LuisAPIKey": "",
  "LuisAPIHostName": "",

  // This is a comma separate list with the App IDs that will have access to the skill.
  // This setting is used in AllowedCallersClaimsValidator.
  // Examples: 
  //    [ "*" ] allows all callers.
  //    [ "AppId1", "AppId2" ] only allows access to parent bots with "AppId1" and "AppId2".
  "AllowedCallers": [ "*" ]
}

Logik für das Weiterleiten von AktivitätenActivity-routing logic

Der Skill unterstützt verschiedene Features.The skill supports a couple different features. Er kann einen Flug buchen oder das Wetter an einem Ort abfragen.It can book a flight or get the weather for a city. Wenn er darüber hinaus eine Nachricht außerhalb eines dieser beiden Kontexte empfängt, kann er mithilfe von LUIS versuchen, die Nachricht zu interpretieren.In addition, if it receives a message outside either of these contexts, it can use LUIS to try to interpret the message. Im Manifest des Skills werden diese Aktionen, ihre Ein- und Ausgabeparameter sowie die Endpunkte des Skills beschrieben.The skill's manifest describes these actions, their input and output parameters, and the skill's endpoints. Beachten Sie, dass der Skill Ereignisse des Typs „BookFlight“ oder „GetWeather“ verarbeiten kann.Of note, the skill can handle a "BookFlight" or "GetWeather" event. Er kann auch Nachrichtenaktivitäten verarbeiten.It can also handle message activities.

Der Skill definiert einen Dialog zum Weiterleiten von Aktivitäten, den er verwendet, um auf Grundlage der anfänglichen vom Skillconsumer eingehenden Aktivität auszuwählen, welche Aktion eingeleitet werden soll.The skill defines an activity-routing dialog it uses to select which action to initiate, based on the initial incoming activity from the skill consumer. Falls vorgesehen, kann das LUIS-Modell die Absichten „Flugbuchung“ und „Wetterbericht“ in einer ersten Nachricht erkennen.If provided, the LUIS model can recognize book-flight and get-weather intents in an initial message.

Die Flugbuchungsaktion ist ein mehrstufiger Prozess, der als separater Dialog implementiert wird.The book-flight action is a multi-step process, implemented as a separate dialog. Nach Beginn der Aktion werden eingehende Aktivitäten von diesem Dialog bearbeitet.Once the action begins, incoming activities are handled by that dialog. Die Wetterberichtsaktion hat Platzhalterlogik, die in einem vollständig implementierten Bot ersetzt würde.The get-weather action has placeholder logic that would be replaced in a fully implemented bot.

Der Dialog zum Weiterleiten von Aktivitäten enthält Code für Folgendes:The activity-routing dialog includes code to:

Die im Skill verwendeten Dialoge erben von der component dialog-Klasse.The dialogs used in the skill inherit from the component dialog class. Weitere Informationen zu Komponentendialogen finden Sie unter Verwalten der Dialogkomplexität.For more about component dialogs, see how to manage dialog complexity.

Initialisieren des DialogsInitialize the dialog

Der Dialog zum Weiterleiten von Aktivitäten enthält einen untergeordneten Dialog zur Buchung eines Flugs.The activity-routing dialog includes a child dialog for booking a flight. Der Hauptwasserfall-Dialog weist einen Schritt auf, mit dem eine Aktion auf Grundlage der empfangenen Anfangsaktivität gestartet wird.The main waterfall dialog has one step that will start an action based on the initial activity received.

Er akzeptiert auch eine LUIS-Erkennungsfunktion.It also accepts a LUIS recognizer. Wenn diese Erkennungsfunktion initialisiert ist, interpretiert der Dialog damit die Absicht einer anfänglichen Nachrichtenaktivität.If this recognizer is initialized, the dialog will use it to interpret the intent of an initial message activity.

DialogSkillBot\Dialogs\ActivityRouterDialog.csDialogSkillBot\Dialogs\ActivityRouterDialog.cs

private readonly DialogSkillBotRecognizer _luisRecognizer;

public ActivityRouterDialog(DialogSkillBotRecognizer luisRecognizer)
    : base(nameof(ActivityRouterDialog))
{
    _luisRecognizer = luisRecognizer;

    AddDialog(new BookingDialog());
    AddDialog(new WaterfallDialog(nameof(WaterfallDialog), new WaterfallStep[] { ProcessActivityAsync }));

    // The initial child Dialog to run.
    InitialDialogId = nameof(WaterfallDialog);
}

Verarbeiten einer anfänglichen AktivitätProcess an initial activity

Im ersten (und einzigen) Schritt des Hauptwasserfall-Dialogs prüft der Skill den eingehenden Aktivitätstyp.In the first (and only) step of the main waterfall dialog, the skill checks the incoming activity type.

  • Ereignisaktivitäten werden an einen on event activity-Handler weitergeleitet, der die entsprechende Aktion basierend auf dem Namen des Ereignisses startet.Event activities are forwarded to an on event activity handler that starts the appropriate action based on the name of the event.
  • Nachrichtenaktivitäten werden an einen on message activity-Handler weitergeleitet, der zusätzliche Verarbeitungsvorgänge ausführt, bevor er entscheidet, was zu tun ist.Message activities are forwarded to an on message activity handler that performs additional processing before deciding what to do.

Wenn der Skill den Typ der eingehenden Aktivität oder den Namen des Ereignisses nicht erkennt, sendet er eine Fehlermeldung und wird beendet.If the skill doesn't recognize the type of the incoming activity or the name of the event, it sends an error message and ends.

DialogSkillBot\Dialogs\ActivityRouterDialog.csDialogSkillBot\Dialogs\ActivityRouterDialog.cs

private async Task<DialogTurnResult> ProcessActivityAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    // A skill can send trace activities, if needed.
    await stepContext.Context.TraceActivityAsync($"{GetType().Name}.ProcessActivityAsync()", label: $"Got ActivityType: {stepContext.Context.Activity.Type}", cancellationToken: cancellationToken);

    switch (stepContext.Context.Activity.Type)
    {
        case ActivityTypes.Event:
            return await OnEventActivityAsync(stepContext, cancellationToken);

        case ActivityTypes.Message:
            return await OnMessageActivityAsync(stepContext, cancellationToken);

        default:
            // We didn't get an activity type we can handle.
            await stepContext.Context.SendActivityAsync(MessageFactory.Text($"Unrecognized ActivityType: \"{stepContext.Context.Activity.Type}\".", inputHint: InputHints.IgnoringInput), cancellationToken);
            return new DialogTurnResult(DialogTurnStatus.Complete);
    }
}
// This method performs different tasks based on the event name.
private async Task<DialogTurnResult> OnEventActivityAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    var activity = stepContext.Context.Activity;
    await stepContext.Context.TraceActivityAsync($"{GetType().Name}.OnEventActivityAsync()", label: $"Name: {activity.Name}. Value: {GetObjectAsJsonString(activity.Value)}", cancellationToken: cancellationToken);

    // Resolve what to execute based on the event name.
    switch (activity.Name)
    {
        case "BookFlight":
            return await BeginBookFlight(stepContext, cancellationToken);

        case "GetWeather":
            return await BeginGetWeather(stepContext, cancellationToken);

        default:
            // We didn't get an event name we can handle.
            await stepContext.Context.SendActivityAsync(MessageFactory.Text($"Unrecognized EventName: \"{activity.Name}\".", inputHint: InputHints.IgnoringInput), cancellationToken);
            return new DialogTurnResult(DialogTurnStatus.Complete);
    }
}

Behandeln von NachrichtenaktivitätenHandle message activities

Wenn die LUIS-Erkennungsfunktion konfiguriert ist, ruft der Skill LUIS auf und startet dann eine auf der Absicht basierende Aktion.If the LUIS recognizer is configured, the skill calls LUIS and then starts an action based on the intent. Wenn die LUIS-Erkennungsfunktion nicht konfiguriert ist oder die Absicht nicht unterstützt wird, sendet der Skill eine Fehlermeldung und wird beendet.If the LUIS recognizer is not configured or the intent is not supported, the skill sends an error message and ends.

DialogSkillBot\Dialogs\ActivityRouterDialog.csDialogSkillBot\Dialogs\ActivityRouterDialog.cs

// This method just gets a message activity and runs it through LUIS. 
private async Task<DialogTurnResult> OnMessageActivityAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    var activity = stepContext.Context.Activity;
    await stepContext.Context.TraceActivityAsync($"{GetType().Name}.OnMessageActivityAsync()", label: $"Text: \"{activity.Text}\". Value: {GetObjectAsJsonString(activity.Value)}", cancellationToken: cancellationToken);

    if (!_luisRecognizer.IsConfigured)
    {
        await stepContext.Context.SendActivityAsync(MessageFactory.Text("NOTE: LUIS is not configured. To enable all capabilities, add 'LuisAppId', 'LuisAPIKey' and 'LuisAPIHostName' to the appsettings.json file.", inputHint: InputHints.IgnoringInput), cancellationToken);
    }
    else
    {
        // Call LUIS with the utterance.
        var luisResult = await _luisRecognizer.RecognizeAsync<FlightBooking>(stepContext.Context, cancellationToken);

        // Create a message showing the LUIS results.
        var sb = new StringBuilder();
        sb.AppendLine($"LUIS results for \"{activity.Text}\":");
        var (intent, intentScore) = luisResult.Intents.FirstOrDefault(x => x.Value.Equals(luisResult.Intents.Values.Max()));
        sb.AppendLine($"Intent: \"{intent}\" Score: {intentScore.Score}");

        await stepContext.Context.SendActivityAsync(MessageFactory.Text(sb.ToString(), inputHint: InputHints.IgnoringInput), cancellationToken);

        // Start a dialog if we recognize the intent.
        switch (luisResult.TopIntent().intent)
        {
            case FlightBooking.Intent.BookFlight:
                return await BeginBookFlight(stepContext, cancellationToken);

            case FlightBooking.Intent.GetWeather:
                return await BeginGetWeather(stepContext, cancellationToken);

            default:
                // Catch all for unhandled intents.
                var didntUnderstandMessageText = $"Sorry, I didn't get that. Please try asking in a different way (intent was {luisResult.TopIntent().intent})";
                var didntUnderstandMessage = MessageFactory.Text(didntUnderstandMessageText, didntUnderstandMessageText, InputHints.IgnoringInput);
                await stepContext.Context.SendActivityAsync(didntUnderstandMessage, cancellationToken);
                break;
        }
    }

    return new DialogTurnResult(DialogTurnStatus.Complete);
}

Beginnen einer mehrstufigen AktionBegin a multi-step action

Die Flugbuchungsaktion leitet einen mehrstufigen Dialog ein, um die Buchungsdetails vom Benutzer abzufragen.The book-flight action starts a multi-step dialog to get the booking details from the user.

Die Wetterberichtsaktion ist nicht implementiert.The get-weather action is not implemented. Derzeit sendet sie eine Platzhalternachricht und wird dann beendet.Currently, it sends a placeholder message and then ends.

DialogSkillBot\Dialogs\ActivityRouterDialog.csDialogSkillBot\Dialogs\ActivityRouterDialog.cs

private async Task<DialogTurnResult> BeginBookFlight(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    var activity = stepContext.Context.Activity;
    var bookingDetails = new BookingDetails();
    if (activity.Value != null)
    {
        bookingDetails = JsonConvert.DeserializeObject<BookingDetails>(JsonConvert.SerializeObject(activity.Value));
    }

    // Start the booking dialog.
    var bookingDialog = FindDialog(nameof(BookingDialog));
    return await stepContext.BeginDialogAsync(bookingDialog.Id, bookingDetails, cancellationToken);
}
private static async Task<DialogTurnResult> BeginGetWeather(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    var activity = stepContext.Context.Activity;
    var location = new Location();
    if (activity.Value != null)
    {
        location = JsonConvert.DeserializeObject<Location>(JsonConvert.SerializeObject(activity.Value));
    }

    // We haven't implemented the GetWeatherDialog so we just display a TODO message.
    var getWeatherMessageText = $"TODO: get weather for here (lat: {location.Latitude}, long: {location.Longitude}";
    var getWeatherMessage = MessageFactory.Text(getWeatherMessageText, getWeatherMessageText, InputHints.IgnoringInput);
    await stepContext.Context.SendActivityAsync(getWeatherMessage, cancellationToken);
    return new DialogTurnResult(DialogTurnStatus.Complete);
}

Zurückgeben eines ErgebnissesReturn a result

Der Skill startet einen Buchungsdialog für die Flugbuchungsaktion.The skill starts a booking dialog for the book-flight action. Da der Dialog zum Weiterleiten von Aktivitäten nur einen Schritt hat, wird mit dem Ende des Buchungsdialogs auch der Dialog zum Weiterleiten von Aktivitäten beendet. Das Dialogergebnis aus dem Buchungsdialog wird zum Dialogergebnis für den Dialog zum Weiterleiten von Aktivitäten.Since the activity-routing dialog has just one step, when the booking dialog ends, the activity-routing dialog also ends, and the dialog result from the booking dialog becomes the dialog result for the activity-routing dialog.

Die Wetterberichtsaktion wird einfach beendet, ohne einen Rückgabewert festzulegen.The get-weather action simply ends without setting a return value.

Abbrechen einer mehrstufigen AktionCanceling a multi-step action

Der Buchungsdialog und sein untergeordneter Datumsauflösungsdialog leiten sich beide vom grundlegenden Abbruch- und Hilfedialog ab, der Nachrichten des Benutzers prüft.The booking dialog and its child date-resolver dialog both derive from the base cancel-and-help dialog, which checks messages from the user.

  • Bei „Hilfe“ oder „?“ wird eine Hilfemeldung angezeigt. Anschließend wird der Konversationsfluss im folgenden Durchgang fortgesetzt.On "help" or "?", it displays a help message, and then continues the conversation flow on the following turn.
  • Bei „cancel“ oder „quit“ werden alle Dialoge abgebrochen, wodurch der Skill beendet wird.On "cancel" or "quit", it cancels all dialogs, which ends the skill.

Weitere Informationen finden Sie unter Behandeln von Benutzerunterbrechungen.For more information, see how to handle user interruptions.

DienstregistrierungService registration

Die Dienste, die für diesen Skill benötigt werden, sind die gleichen, die für einen Skillbot im Allgemeinen benötigt werden.The services needed for this skill are the same as those needed for a skill bot in general. Eine Erläuterung der erforderlichen Dienste finden Sie unter Implementieren eines Skills.See how to implement a skill for a discussion of the required services.

SkillmanifestSkill manifest

Ein Qualifikationsmanifest ist eine JSON-Datei, in der die von der Qualifikation durchführbaren Aktivitäten, die Eingabe- und Ausgabeparameter und die Endpunkte der Qualifikation beschrieben sind.A skill manifest is a JSON file that describes the activities the skill can perform, its input and output parameters, and the skill's endpoints. Das Manifest enthält die Informationen, die Sie für den Zugriff auf die Qualifikation mit einem anderen Bot benötigen.The manifest contains the information you need to access the skill from another bot.

DialogSkillBot\wwwroot\manifest\dialogchildbot-manifest-1.0.jsonDialogSkillBot\wwwroot\manifest\dialogchildbot-manifest-1.0.json

{
  "$schema": "https://schemas.botframework.com/schemas/skills/skill-manifest-2.0.0.json",
  "$id": "DialogSkillBot",
  "name": "Skill bot with dialogs",
  "version": "1.0",
  "description": "This is a sample skill definition for multiple activity types.",
  "publisherName": "Microsoft",
  "privacyUrl": "https://dialogskillbot.contoso.com/privacy.html",
  "copyright": "Copyright (c) Microsoft Corporation. All rights reserved.",
  "license": "",
  "iconUrl": "https://dialogskillbot.contoso.com/icon.png",
  "tags": [
    "sample",
    "travel",
    "weather",
    "luis"
  ],
  "endpoints": [
    {
      "name": "default",
      "protocol": "BotFrameworkV3",
      "description": "Default endpoint for the skill.",
      "endpointUrl": "https://dialogskillbot.contoso.com/api/messages",
      "msAppId": "00000000-0000-0000-0000-000000000000"
    }
  ],
  "activities": {
    "bookFlight": {
      "description": "Books a flight (multi turn).",
      "type": "event",
      "name": "BookFlight",
      "value": {
        "$ref": "#/definitions/bookingInfo"
      },
      "resultValue": {
        "$ref": "#/definitions/bookingInfo"
      }
    },
    "getWeather": {
      "description": "Retrieves and returns the weather for the user's location.",
      "type": "event",
      "name": "GetWeather",
      "value": {
        "$ref": "#/definitions/location"
      },
      "resultValue": {
        "$ref": "#/definitions/weatherReport"
      }
    },
    "passthroughMessage": {
      "type": "message",
      "description": "Receives the user's utterance and attempts to resolve it using the skill's LUIS models.",
      "value": {
        "type": "object"
      }
    }
  },
  "definitions": {
    "bookingInfo": {
      "type": "object",
      "required": [
        "origin"
      ],
      "properties": {
        "origin": {
          "type": "string",
          "description": "This is the origin city for the flight."
        },
        "destination": {
          "type": "string",
          "description": "This is the destination city for the flight."
        },
        "travelDate": {
          "type": "string",
          "description": "The date for the flight in YYYY-MM-DD format."
        }
      }
    },
    "weatherReport": {
      "type": "array",
      "description": "Array of forecasts for the next week.",
      "items": [
        {
          "type": "string"
        }
      ]
    },
    "location": {
      "type": "object",
      "description": "Location metadata.",
      "properties": {
        "latitude": {
          "type": "number",
          "title": "Latitude"
        },
        "longitude": {
          "type": "number",
          "title": "Longitude"
        },
        "postalCode": {
          "type": "string",
          "title": "Postal code"
        }
      }
    }
  }
}

Das Schema des Qualifikationsmanifests ist eine JSON-Datei, in der das Schema des Qualifikationsmanifests beschrieben ist.The skill manifest schema is a JSON file that describes the schema of the skill manifest. Die neueste Schemaversion ist v2.1.The latest schema version is v2.1.

Testen des SkillbotsTest the skill bot

Sie können den Skill im Emulator mit dem Skillconsumer testen.You can test the skill in the Emulator with the skill consumer. Dazu müssen Sie die Skill- und Skillconsumerbots gleichzeitig ausführen.To do so, you need to run both the skill and skill consumer bots at the same time. Informationen zum Konfigurieren des Skills finden Sie unter Verwenden eines Dialogs zum Nutzen eines Skills.See how to use a dialog to consume a skill for information on how to configure the skill.

Laden Sie die aktuelle Version von Bot Framework Emulator herunter, und installieren Sie sie.Download and install the latest Bot Framework Emulator.

  1. Führen Sie den „dialog skill bot“ und den „dialog root bot“ lokal auf Ihrem Computer aus.Run the dialog skill bot and dialog root bot locally on your machine. Wenn Sie eine Anleitung benötigen, helfen Ihnen die Infodateien für das C#-, JavaScript- bzw. Python-Beispiel weiter.If you need instructions, refer to the README file for the C#, JavaScript or Python sample.
  2. Testen Sie den Bot im Emulator.Use the Emulator to test the bot.
    • Wenn Sie sich zum ersten Mal an der Konversation beteiligen, zeigt der Bot eine Begrüßung an und fragt Sie, welchen Skill Sie aufrufen möchten.When you first join the conversation, the bot displays a welcome message and asks you what skill you would like to call. Der Skillbot für dieses Beispiel hat nur einen Skill.The skill bot for this sample has just one skill.
    • Wählen Sie DialogSkillBot aus.Select DialogSkillBot.
  3. Als Nächstes bittet Sie der Bot, eine Aktion für den Skill auszuwählen.The bot next asks you to choose an action for the skill. Wählen Sie „BookFlight“.Choose "BookFlight".
    1. Der Skill beginnt seine Flugbuchungsaktion. Beantworten Sie die Aufforderungen.The skill begins its book-flight action; answer the prompts.
    2. Wenn der Skill abgeschlossen ist, zeigt der Stammbot die Buchungsdetails an, bevor er erneut nach dem Skill fragt, den Sie aufrufen möchten.When the skill completes, the root bot displays the booking details before prompting again for the skill you'd like to call.
  4. Wählen Sie erneut DialogSkillBot und „BookFlight“ aus.Select DialogSkillBot again and "BookFlight".
    1. Beantworten Sie die erste Aufforderung, und geben Sie „Abbrechen“ ein, um die Aktion abzubrechen.Answer the first prompt, then enter "cancel" to cancel the action.
    2. Der Skillbot endet, ohne die Aktion abzuschließen. Der Consumer fordert zur Angabe des Skills auf, den Sie aufrufen möchten.The skill bot ends without completing the action, and the consumer prompts for the skill you'd like to call.

Zusätzliche InformationenAdditional information