Freigeben über

Implementieren eines Skill-Consumers

  • Artikel

GILT FÜR: SDK v4

Sie können Qualifikationen verwenden, um einen anderen Bot zu erweitern. Eine Qualifikation ist ein Bot, der eine Reihe von Aufgaben für einen anderen Bot durchführen kann und ein Manifest nutzt, um seine Oberfläche zu beschreiben. Ein Stamm-Bot ist ein Bot für Benutzer, der eine oder mehrere Qualifikationen aufrufen kann. Ein Stamm-Bot ist eine Art von Skill-Consumer.

  • Ein Skillconsumer muss die Anspruchsvalidierung nutzen, um zu verwalten, welche Skills auf ihn zugreifen können.
  • Ein Skill-Consumer kann mehrere Qualifikationen verwenden.
  • Entwickler, die keinen Zugriff auf den Quellcode der Qualifikation haben, können die Informationen im Manifest der Qualifikation nutzen, um ihren „Skill-Consumer“ zu entwerfen.

In diesem Artikel wird veranschaulicht, wie Sie einen Skill-Consumer implementieren, von dem die Echo-Qualifikation (Echo Skill) genutzt wird, um die Eingabe des Benutzers zu wiederholen. Ein Beispiel für ein Qualifikationsmanifest und Informationen zur Implementierung der Echo-Qualifikation finden Sie unter Implementieren einer Qualifikation.

Informationen zum Verwenden eines Dialogs zum Nutzen eines Skills finden Sie unter Verwenden eines Dialogs zum Nutzen eines Skills.

Einige Typen von Skillconsumern sind nicht in der Lage, einige Typen von Skill-Bots zu verwenden. In der folgenden Tabelle wird beschrieben, welche Kombinationen unterstützt werden.

  Mehrinstanzenfähiger Skill Single-Tenant-Skill Skill der benutzerseitig zugewiesenen verwalteten Identität
Mehrinstanzenfähige Verbraucher Unterstützt Nicht unterstützt Nicht unterstützt
Einzelinstanzenfähige Verbraucher Nicht unterstützt Unterstützt, wenn beide Apps zu demselben Mandanten gehören Unterstützt, wenn beide Apps zu demselben Mandanten gehören
Consumer einer benutzerseitig zugewiesenen verwalteten Identität Nicht unterstützt Unterstützt, wenn beide Apps zu demselben Mandanten gehören Unterstützt, wenn beide Apps zu demselben Mandanten gehören

Hinweis

Die JavaScript-, C#- und Python-SDKs für Bot Framework werden weiterhin unterstützt, das Java-SDK wird jedoch eingestellt und der langfristige Support endet im November 2023.

Bestehende Bots, die mit dem Java SDK erstellt wurden, werden weiterhin funktionieren.

Für das erstellen eines neuen Bots sollten Sie Microsoft Copilot Studio verwenden und lesen, wie Sie die richtige Copilot-Lösung auswählen.

Weitere Informationen finden Sie unter Die Zukunft des Bot-Design.

Voraussetzungen

Hinweis

Ab Version 4.11 benötigen Sie keine App-ID und kein Passwort, um einen Skillconsumer lokal im Bot Framework Emulator zu testen. Ein Azure-Abonnement ist nach wie vor erforderlich, um Ihren Consumer in Azure bereitzustellen oder einen bereitgestellte Skill zu nutzen.

Informationen zu diesem Beispiel

Das Beispiel skills simple bot-to-bot enthält Projekte für zwei Bots:

  • Echo Skill Bot (Echo-Bot für Qualifikation) zum Implementieren der Qualifikation.
  • Simple Root Bot (einfacher Stamm-Bot) zum Implementieren eines Stamm-Bots, der die Qualifikation nutzt.

Der Schwerpunkt dieses Artikels liegt auf dem Stamm-Bot, und es wird die Unterstützungslogik in den Bot- und Adapterobjekten beschrieben. Darüber hinaus werden Objekte beschrieben, die zum Austauschen von Aktivitäten mit einer Qualifikation verwendet werden. Dazu gehören:

  • Ein Skill-Client, der zum Senden von Aktivitäten an eine Qualifikation verwendet wird.
  • Ein Skill-Handler, der zum Empfangen von Aktivitäten von einer Qualifikation verwendet wird.
  • Eine Konversations-ID-Factory für Qualifikationen, die vom Skill-Client und -Handler genutzt wird, um die Übersetzung zwischen dem Benutzer/Stamm-Konversationsverweis und dem Stamm/Qualifikation-Konversationsverweis durchzuführen.

Weitere Informationen zum „Echo Skill Bot“ finden Sie unter Implementieren einer Qualifikation.

Ressourcen

Bei eingesetzten Bots erfordert die Bot-zu-Bot-Authentifizierung, dass jeder teilnehmende Bot über gültige Identitätsinformationen verfügt. Sie können jedoch Mandanten-Skills und Skillconsumer mit dem Emulator lokal ohne App-ID und Passwort testen.

Anwendungskonfiguration

  1. Fügen Sie optional die Identitätsinformationen des Stamm-Bots zur Konfigurationsdatei hinzu. Wenn entweder der Skill oder der Skillconsumer Identitätsinformationen liefert, müssen beide dies tun.
  2. Fügen Sie den Skill-Host-Endpunkt (die Dienst- oder Rückruf-URL) hinzu, an die die Antwort der Skills an den Skillconsumer erfolgen soll.
  3. Fügen Sie einen Eintrag für jede Qualifikation hinzu, die vom Skill-Consumer verwendet wird. Jeder Eintrag umfasst Folgendes:
    • Eine ID, die vom Skill-Consumer verwendet wird, um die einzelnen Qualifikationen zu identifizieren.
    • Optional kann die App oder Client-ID des Skill verwendet werden.
    • Den Messagingendpunkt der Qualifikation.

Hinweis

Wenn entweder der Skill oder der Skillconsumer Identitätsinformationen liefert, müssen beide dies tun.

SimpleRootBot\appsettings.json

Fügen Sie optional die Identitätsinformationen des Stamm-Bots hinzu und fügen Sie die App oder Client-ID für den Echo-Skill-Bot hinzu.

{
  "MicrosoftAppType": "",
  "MicrosoftAppId": "",
  "MicrosoftAppPassword": "",
  "MicrosoftAppTenantId": "",
  "SkillHostEndpoint": "http://localhost:3978/api/skills/",
  "BotFrameworkSkills": [
    {
      "Id": "EchoSkillBot",
      "AppId": "",
      "SkillEndpoint": "http://localhost:39783/api/messages"
    }
  ]
}

Konfiguration von Qualifikationen

In diesem Beispiel werden Informationen zu den einzelnen Qualifikationen in die Konfigurationsdatei einer Sammlung mit Objekten vom Typ Qualifikation eingelesen.

SimpleRootBot\SkillsConfiguration.cs

public class SkillsConfiguration
{
    public SkillsConfiguration(IConfiguration configuration)
    {
        var section = configuration?.GetSection("BotFrameworkSkills");
        var skills = section?.Get<BotFrameworkSkill[]>();
        if (skills != null)
        {
            foreach (var skill in skills)
            {
                Skills.Add(skill.Id, skill);
            }
        }

        var skillHostEndpoint = configuration?.GetValue<string>(nameof(SkillHostEndpoint));
        if (!string.IsNullOrWhiteSpace(skillHostEndpoint))
        {
            SkillHostEndpoint = new Uri(skillHostEndpoint);
        }
    }

    public Uri SkillHostEndpoint { get; }

    public Dictionary<string, BotFrameworkSkill> Skills { get; } = new Dictionary<string, BotFrameworkSkill>();
}

Konversations-ID-Factory

Hiermit wird die Konversations-ID für die Qualifikation erstellt, und die ursprüngliche ID der Benutzerkonversation kann aus der Konversations-ID der Qualifikation wiederhergestellt werden.

Die Konversations-ID-Factory für dieses Beispiel unterstützt ein einfaches Szenario, für das Folgendes gilt:

  • Der Stamm-Bot ist dafür ausgelegt, eine bestimmte Qualifikation zu nutzen.
  • Der Stamm-Bot verfügt jeweils nur über eine aktive Konversation mit einer Qualifikation.

Das SDK stellt eine SkillConversationIdFactory-Klasse bereit, die über alle Skills hinweg verwendet werden kann, ohne dass der Quellcode repliziert werden muss. Die Unterhaltungs-ID-Zuordnungsinstanz ist in Startup.cs konfiguriert.

Entwerfen Sie Ihre Konversations-ID-Factory wie folgt, um komplexere Szenarien zu unterstützen:

  • Mit der create skill conversation ID-Methode wird die entsprechende Konversations-ID für eine Qualifikation abgerufen bzw. generiert.
  • Mit der get conversation reference-Methode wird die richtige Benutzerkonversation abgerufen.

Skill-Client und Skill-Handler

Der Skill-Consumer verwendet einen Skill-Client, um Aktivitäten an die Qualifikation weiterzuleiten. Der Client nutzt hierfür die Konfigurationsinformationen für die Qualifikation und die Konversations-ID-Factory.

Der Skill-Consumer nutzt einen Skill-Handler, um Aktivitäten von einer Qualifikation zu empfangen. Der Handler nutzt hierfür die Konversations-ID-Factory, die Authentifizierungskonfiguration und einen Anmeldeinformationsanbieter und verfügt zudem über Abhängigkeiten vom Adapter und Aktivitätshandler des Stamm-Bots.

SimpleRootBot\Startup.cs

services.AddSingleton<IBotFrameworkHttpAdapter>(sp => sp.GetService<CloudAdapter>());
services.AddSingleton<BotAdapter>(sp => sp.GetService<CloudAdapter>());

Der HTTP-Datenverkehr der Qualifikation fließt an den URL-Dienstendpunkt, der vom Skill-Consumer für die Qualifikation angekündigt wird. Verwenden Sie einen sprachspezifischen Endpunkthandler, um Datenverkehr an den Skill-Handler weiterzuleiten.

Für den Skill-Standardhandler gilt Folgendes:

  • Wenn eine Anwendungs-ID und ein Passwort vorhanden sind, wird ein Authentifizierungs-Konfigurationsobjekt verwendet, um die Authentifizierung zwischen Bots und die Überprüfung von Ansprüchen durchzuführen.
  • Verwendet die Konversations-ID-Factory, um die Rückübersetzung von der Consumer/Qualifikation-Konversation in die Stamm/Benutzer-Konversation durchzuführen.
  • Generiert eine proaktive Nachricht, damit der Skill-Consumer wieder einen Stamm/Benutzer-Durchlaufkontext herstellen und Aktivitäten an den Benutzer weiterleiten kann.

Aktivitätshandlerlogik

In Bezug auf die Logik des Skill-Consumers sollte Folgendes beachtet werden:

  • Ermitteln Sie, ob aktive Qualifikationen vorhanden sind, und leiten Sie dafür je nach Bedarf Aktivitäten weiter.
  • Achten Sie darauf, wann ein Benutzer eine Anforderung sendet, die an eine Qualifikation weitergeleitet werden soll, und starten Sie dann die Qualifikation.
  • Suchen Sie nach einer endOfConversation-Aktivität einer beliebigen aktiven Qualifikation, um verfolgen zu können, wann sie abgeschlossen wird.
  • Fügen Sie Logik hinzu (falls zutreffend), mit der der Benutzer oder Skill-Consumer eine Qualifikation abbrechen kann, die noch nicht abgeschlossen wurde.
  • Speichern Sie den Zustand, bevor Sie eine Qualifikation aufrufen, da es sein kann, dass eine Antwort an eine andere Instanz des Skill-Consumers zurückgesendet wird.

SimpleRootBot\Bots\RootBot.cs

Der Stamm-Bot verfügt über Abhängigkeiten in Bezug auf den Konversationszustand, die Qualifikationsinformationen, den Skill-Client und die allgemeine Konfiguration. ASP.NET stellt diese Objekte per Abhängigkeitsinjektion bereit. Der Stamm-Bot definiert auch einen Eigenschaftenaccessor für den Konversationszustand, um nachzuverfolgen, welche Qualifikation aktiv ist.

public static readonly string ActiveSkillPropertyName = $"{typeof(RootBot).FullName}.ActiveSkillProperty";
private readonly IStatePropertyAccessor<BotFrameworkSkill> _activeSkillProperty;
private readonly string _botId;
private readonly ConversationState _conversationState;
private readonly BotFrameworkAuthentication _auth;
private readonly SkillConversationIdFactoryBase _conversationIdFactory;
private readonly SkillsConfiguration _skillsConfig;
private readonly BotFrameworkSkill _targetSkill;

public RootBot(BotFrameworkAuthentication auth, ConversationState conversationState, SkillsConfiguration skillsConfig, SkillConversationIdFactoryBase conversationIdFactory, IConfiguration configuration)
{
    _auth = auth ?? throw new ArgumentNullException(nameof(auth));
    _conversationState = conversationState ?? throw new ArgumentNullException(nameof(conversationState));
    _skillsConfig = skillsConfig ?? throw new ArgumentNullException(nameof(skillsConfig));
    _conversationIdFactory = conversationIdFactory ?? throw new ArgumentNullException(nameof(conversationIdFactory));

    if (configuration == null)
    {
        throw new ArgumentNullException(nameof(configuration));
    }

    _botId = configuration.GetSection(MicrosoftAppCredentials.MicrosoftAppIdKey)?.Value;

    // We use a single skill in this example.
    var targetSkillId = "EchoSkillBot";
    _skillsConfig.Skills.TryGetValue(targetSkillId, out _targetSkill);

    // Create state property to track the active skill
    _activeSkillProperty = conversationState.CreateProperty<BotFrameworkSkill>(ActiveSkillPropertyName);
}

Dieses Beispiel enthält eine Hilfsmethode für die Weiterleitung von Aktivitäten an eine Qualifikation. Der Konversationszustand wird gespeichert, bevor die Qualifikation aufgerufen wird, und es wird überprüft, ob die HTTP-Anforderung erfolgreich war.

private async Task SendToSkill(ITurnContext turnContext, BotFrameworkSkill targetSkill, CancellationToken cancellationToken)
{
    // NOTE: Always SaveChanges() before calling a skill so that any activity generated by the skill
    // will have access to current accurate state.
    await _conversationState.SaveChangesAsync(turnContext, force: true, cancellationToken: cancellationToken);

    // Create a conversationId to interact with the skill and send the activity
    var options = new SkillConversationIdFactoryOptions
    {
        FromBotOAuthScope = turnContext.TurnState.Get<string>(BotAdapter.OAuthScopeKey),
        FromBotId = _botId,
        Activity = turnContext.Activity,
        BotFrameworkSkill = targetSkill
    };
    var skillConversationId = await _conversationIdFactory.CreateSkillConversationIdAsync(options, cancellationToken);

    using var client = _auth.CreateBotFrameworkClient();

    // route the activity to the skill
    var response = await client.PostActivityAsync(_botId, targetSkill.AppId, targetSkill.SkillEndpoint, _skillsConfig.SkillHostEndpoint, skillConversationId, turnContext.Activity, cancellationToken);

    // Check response status
    if (!(response.Status >= 200 && response.Status <= 299))
    {
        throw new HttpRequestException($"Error invoking the skill id: \"{targetSkill.Id}\" at \"{targetSkill.SkillEndpoint}\" (status is {response.Status}). \r\n {response.Body}");
    }
}

Beachten Sie, dass der Stammbot Logik für das Weiterleiten von Aktivitäten an den Skill beinhaltet, mit der der Skill auf Anforderung des Benutzers gestartet und bei Abschluss des Skills beendet wird.

protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
{
    if (turnContext.Activity.Text.Contains("skill"))
    {
        await turnContext.SendActivityAsync(MessageFactory.Text("Got it, connecting you to the skill..."), cancellationToken);

        // Save active skill in state
        await _activeSkillProperty.SetAsync(turnContext, _targetSkill, cancellationToken);

        // Send the activity to the skill
        await SendToSkill(turnContext, _targetSkill, cancellationToken);
        return;
    }

    // just respond
    await turnContext.SendActivityAsync(MessageFactory.Text("Me no nothin'. Say \"skill\" and I'll patch you through"), cancellationToken);

    // Save conversation state
    await _conversationState.SaveChangesAsync(turnContext, force: true, cancellationToken: cancellationToken);
}

protected override async Task OnEndOfConversationActivityAsync(ITurnContext<IEndOfConversationActivity> turnContext, CancellationToken cancellationToken)
{
    // forget skill invocation
    await _activeSkillProperty.DeleteAsync(turnContext, cancellationToken);

    // Show status message, text and value returned by the skill
    var eocActivityMessage = $"Received {ActivityTypes.EndOfConversation}.\n\nCode: {turnContext.Activity.Code}";
    if (!string.IsNullOrWhiteSpace(turnContext.Activity.Text))
    {
        eocActivityMessage += $"\n\nText: {turnContext.Activity.Text}";
    }

    if ((turnContext.Activity as Activity)?.Value != null)
    {
        eocActivityMessage += $"\n\nValue: {JsonConvert.SerializeObject((turnContext.Activity as Activity)?.Value)}";
    }

    await turnContext.SendActivityAsync(MessageFactory.Text(eocActivityMessage), cancellationToken);

    // We are back at the root
    await turnContext.SendActivityAsync(MessageFactory.Text("Back in the root bot. Say \"skill\" and I'll patch you through"), cancellationToken);

    // Save conversation state
    await _conversationState.SaveChangesAsync(turnContext, cancellationToken: cancellationToken);
}

OnTurn-Fehlerhandler

Wenn ein Fehler auftritt, löscht der Adapter den Konversationszustand, um die Konversation mit dem Benutzer zurückzusetzen und einen dauerhaften Fehlerzustand zu vermeiden.

Es ist eine bewährte Vorgehensweise, eine Aktivität vom Typ end of conversation an aktive Qualifikationen zu senden, bevor der Konversationszustand im Skill-Consumer gelöscht wird. Auf diese Weise kann die Qualifikation alle Ressourcen freigeben, die der Consumer/Qualifikation-Konversation zugeordnet sind, bevor der Skill-Consumer die Konversation freigibt.

SimpleRootBot\AdapterWithErrorHandler.cs

In diesem Beispiel ist die Durchlauffehlerlogik auf mehrere Hilfsmethoden aufgeteilt.

private async Task HandleTurnError(ITurnContext turnContext, Exception exception)
{
    // Log any leaked exception from the application.
    // NOTE: In production environment, you should consider logging this to
    // Azure Application Insights. Visit https://aka.ms/bottelemetry to see how
    // to add telemetry capture to your bot.
    _logger.LogError(exception, $"[OnTurnError] unhandled error : {exception.Message}");

    await SendErrorMessageAsync(turnContext, exception);
    await EndSkillConversationAsync(turnContext);
    await ClearConversationStateAsync(turnContext);
}

private async Task SendErrorMessageAsync(ITurnContext turnContext, Exception exception)
{
    try
    {
        // Send a message to the user
        var errorMessageText = "The bot encountered an error or bug.";
        var errorMessage = MessageFactory.Text(errorMessageText, errorMessageText, InputHints.IgnoringInput);
        await turnContext.SendActivityAsync(errorMessage);

        errorMessageText = "To continue to run this bot, please fix the bot source code.";
        errorMessage = MessageFactory.Text(errorMessageText, errorMessageText, InputHints.ExpectingInput);
        await turnContext.SendActivityAsync(errorMessage);

        // Send a trace activity, which will be displayed in the Bot Framework Emulator
        await turnContext.TraceActivityAsync("OnTurnError Trace", exception.ToString(), "https://www.botframework.com/schemas/error", "TurnError");
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, $"Exception caught in SendErrorMessageAsync : {ex}");
    }
}

private async Task EndSkillConversationAsync(ITurnContext turnContext)
{
    if (_skillsConfig == null)
    {
        return;
    }

    try
    {
        // Inform the active skill that the conversation is ended so that it has
        // a chance to clean up.
        // Note: ActiveSkillPropertyName is set by the RooBot while messages are being
        // forwarded to a Skill.
        var activeSkill = await _conversationState.CreateProperty<BotFrameworkSkill>(RootBot.ActiveSkillPropertyName).GetAsync(turnContext, () => null);
        if (activeSkill != null)
        {
            var botId = _configuration.GetSection(MicrosoftAppCredentials.MicrosoftAppIdKey)?.Value;

            var endOfConversation = Activity.CreateEndOfConversationActivity();
            endOfConversation.Code = "RootSkillError";
            endOfConversation.ApplyConversationReference(turnContext.Activity.GetConversationReference(), true);

            await _conversationState.SaveChangesAsync(turnContext, true);

            using var client = _auth.CreateBotFrameworkClient();

            await client.PostActivityAsync(botId, activeSkill.AppId, activeSkill.SkillEndpoint, _skillsConfig.SkillHostEndpoint, endOfConversation.Conversation.Id, (Activity)endOfConversation, CancellationToken.None);
        }
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, $"Exception caught on attempting to send EndOfConversation : {ex}");
    }
}

private async Task ClearConversationStateAsync(ITurnContext turnContext)
{
    try
    {
        // Delete the conversationState for the current conversation to prevent the
        // bot from getting stuck in a error-loop caused by being in a bad state.
        // ConversationState should be thought of as similar to "cookie-state" in a Web pages.
        await _conversationState.DeleteAsync(turnContext);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, $"Exception caught on attempting to Delete ConversationState : {ex}");
    }
}

Endpunkt für Qualifikation

Der Bot definiert einen Endpunkt, mit dem eingehende Qualifikationsaktivitäten an den Skill-Handler des Stamm-Bots weitergeleitet werden.

SimpleRootBot\Controllers\SkillController.cs

[ApiController]
[Route("api/skills")]
public class SkillController : ChannelServiceController
{
    public SkillController(ChannelServiceHandlerBase handler)
        : base(handler)
    {
    }
}

Dienstregistrierung

Fügen Sie ein Objekt für die Authentifizierungskonfiguration mit den zugehörigen Anspruchsüberprüfungen sowie alle zusätzlichen Objekte hinzu. In diesem Beispiel wird die gleiche Authentifizierungs-Konfigurationslogik zum Überprüfen von Aktivitäten von Benutzern und Skills verwendet.

SimpleRootBot\Startup.cs

// Register the skills configuration class
services.AddSingleton<SkillsConfiguration>();

// Register AuthConfiguration to enable custom claim validation.
services.AddSingleton(sp =>
{
    var allowedSkills = sp.GetService<SkillsConfiguration>().Skills.Values.Select(s => s.AppId).ToList();

    var claimsValidator = new AllowedSkillsClaimsValidator(allowedSkills);

    // If TenantId is specified in config, add the tenant as a valid JWT token issuer for Bot to Skill conversation.
    // The token issuer for MSI and single tenant scenarios will be the tenant where the bot is registered.
    var validTokenIssuers = new List<string>();
    var tenantId = sp.GetService<IConfiguration>().GetSection(MicrosoftAppCredentials.MicrosoftAppTenantIdKey)?.Value;

    if (!string.IsNullOrWhiteSpace(tenantId))
    {
        // For SingleTenant/MSI auth, the JWT tokens will be issued from the bot's home tenant.
        // Therefore, these issuers need to be added to the list of valid token issuers for authenticating activity requests.
        validTokenIssuers.Add(string.Format(CultureInfo.InvariantCulture, AuthenticationConstants.ValidTokenIssuerUrlTemplateV1, tenantId));
        validTokenIssuers.Add(string.Format(CultureInfo.InvariantCulture, AuthenticationConstants.ValidTokenIssuerUrlTemplateV2, tenantId));
        validTokenIssuers.Add(string.Format(CultureInfo.InvariantCulture, AuthenticationConstants.ValidGovernmentTokenIssuerUrlTemplateV1, tenantId));
        validTokenIssuers.Add(string.Format(CultureInfo.InvariantCulture, AuthenticationConstants.ValidGovernmentTokenIssuerUrlTemplateV2, tenantId));
    }

    return new AuthenticationConfiguration
    {
        ClaimsValidator = claimsValidator,
        ValidTokenIssuers = validTokenIssuers
    };
});

Testen des Stamm-Bots

Sie können den Skill-Consumer im Emulator wie einen regulären Bot testen. Sie müssen aber sowohl den Bot für die Qualifikation als auch den Bot für den Skill-Consumer ausführen. Informationen zum Konfigurieren der Qualifikation finden Sie unter Implementieren einer Qualifikation.

Laden Sie die aktuelle Version von Bot Framework Emulator herunter, und installieren Sie sie.

  1. Führen Sie den „Echo Skill Bot“ und den „Simple Root Bot“ lokal auf Ihrem Computer aus. Wenn Sie eine Anleitung benötigen, helfen Ihnen die README-Datei des Beispiels für C#, JavaScript, Java oder Python weiter.
  2. Verwenden Sie den Emulator, um den Bot wie unten dargestellt zu testen. Wenn Sie eine end- oder stop-Nachricht an die Qualifikation senden, sendet die Qualifikation zusätzlich zur Antwortnachricht eine endOfConversation-Aktivität an den Stamm-Bot. Die code-Eigenschaft der endOfConversation-Aktivität gibt an, dass die Qualifikation erfolgreich abgeschlossen wurde.

Beispieltranskript einer Interaktion mit dem Qualifikationsverbraucher.

Mehr über Debuggen

Da der Datenverkehr zwischen Skills und Skill-Verbraucher authentifiziert wird, gibt es zusätzliche Schritte beim Debuggen solcher Bots.

  • Der Skill-Verbraucher und alle Skills, die er direkt oder indirekt verbraucht, müssen ausgeführt werden.
  • Wenn die Bots lokal ausgeführt werden und einer der Bots über eine App-ID und ein Passwort verfügt, müssen alle Bots gültige IDs und Passwörter besitzen.
  • Wenn alle Bots bereitgestellt werden, erfahren Sie, wie Sie einen Bot über einen beliebigen Kanal mithilfe von Devtunnel debuggen.
  • Wenn einige der Bots lokal ausgeführt werden und einige bereitgestellt werden, erfahren Sie, wie Sie einen Skill oder einen Skill-Verbraucher debuggen.

Andernfalls können Sie einen Skill-Verbraucher oder einen Skill ähnlich debuggen, wie Sie andere Bots debuggen. Weitere Informationen finden Sie unter Debuggen eines Bots und Debuggen mit dem Bot Framework Emulator.

Weitere Informationen

Hier werden einige Aspekte beschrieben, die Sie beim Implementieren eines komplexeren Stamm-Bots berücksichtigen sollten.

So lassen Sie für Benutzer das Abbrechen einer Qualifikation mit mehreren Schritten zu

Der Stamm-Bot sollte die Nachricht des Benutzers überprüfen, bevor er sie an die aktive Qualifikation weiterleitet. Wenn der Benutzer den aktuellen Prozess abbrechen möchte, kann der Stamm-Bot eine endOfConversation-Aktivität an die Qualifikation senden, anstatt die Nachricht weiterzuleiten.

So tauschen Sie die Daten zwischen Stamm-Bots und Skill-Bots aus

Zum Senden von Parametern an die Qualifikation kann der Skill-Consumer die value-Eigenschaft für die Nachrichten festlegen, die er an die Qualifikation sendet. Der Skill-Consumer sollte die value-Eigenschaft überprüfen, wenn die Qualifikation eine endOfConversation-Aktivität sendet, um Rückgabewerte von der Qualifikation zu erhalten.

So verwenden Sie mehrere Qualifikationen

  • Wenn eine Qualifikation aktiv ist, muss der Stamm-Bot ermitteln, welche Qualifikation dies ist, und die Nachricht des Benutzers an die richtige Qualifikation weiterleiten.
  • Falls keine Qualifikation aktiv ist, muss der Stamm-Bot anhand des Botzustands und der Eingabe des Benutzers ermitteln, welche Qualifikation gestartet werden soll (falls zutreffend).
  • Wenn Sie für Benutzer den Wechsel zwischen mehreren gleichzeitigen Qualifikationen zulassen möchten, muss der Stamm-Bot ermitteln, mit welcher aktiven Qualifikation der Benutzer interagieren möchte, bevor die Nachricht des Benutzers weitergeleitet wird.

So verwenden Sie einen Zustellungsmodus für erwartete Antworten

So verwenden Sie einen Zustellungsmodus für erwartete Antworten:

  • Klonen Sie die Aktivität aus dem Turnkontext.
  • Legen Sie die Eigenschaft des Zustellungsmodus der neuen Aktivität auf „ExpectReplies“ fest, bevor Sie die Aktivität vom Stamm-Bot an Skills senden.
  • Lesen sie erwartete Antworten aus dem Aufrufantwort-Text, der von der Anforderungsantwort zurückgegeben wird.
  • Verarbeiten Sie jede Aktivität, entweder innerhalb des Stamm-Bots oder durch Senden an den Kanal, der die ursprüngliche Anforderung initiiert hat.

Antworten zu erwarten kann in Situationen nützlich sein, in denen der Bot, der auf eine Aktivität antwortet, dieselbe Instance des Bots sein muss, der die Aktivität erhalten hat.