Implementieren eines Skill-Consumers

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 Haupt-Bot ist ein benutzerorientierter Bot, der eine oder mehrere Fähigkeiten 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 Fähigkeitsnutzer implementieren, der die Echo-Fähigkeit verwendet, 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 zur Nutzung eines Dialogs, um eine Fähigkeit zu nutzen, finden Sie unter Verwenden eines Dialogs zur Nutzung einer Fähigkeit.

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 Consumer	Unterstützt	Nicht unterstützt	Nicht unterstützt
Einzelinstanzenfähige Consumer	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

Um Agents mit Ihrer Wahl von KI-Diensten, Orchestrierung und Wissen zu erstellen, sollten Sie das Microsoft 365 Agents SDK verwenden. Das Agents SDK unterstützt C#, JavaScript oder Python. Weitere Informationen zum Agents SDK finden Sie unter aka.ms/agents. Wenn Sie nach einer SaaS-basierten Agent-Plattform suchen, ziehen Sie Microsoft Copilot Studio in Betracht. Wenn Sie über einen vorhandenen Bot verfügen, der mit dem Bot Framework SDK erstellt wurde, können Sie Ihren Bot auf das Agents SDK aktualisieren. Sie können die wichtigsten Änderungen und Updates im Bot Framework SDK zu Agents SDK-Migrationsleitfaden überprüfen. Supporttickets für das Bot Framework SDK werden ab dem 31. Dezember 2025 nicht mehr bearbeitet.

Voraussetzungen

• Kenntnisse: Funktionsweise von Bots, Funktionsweise von Skill-Bots und Implementieren einer Qualifikation.
• Optional, ein Azure-Abonnement. Falls Sie kein Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.
• Eine Kopie des Beispiels skills simple bot-to-bot in C#, JavaScript, Java oder Python.

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 Artikel konzentriert sich auf den Stamm-Bot, der Unterstützungslogik in seinen Bot- und Adapterobjekten enthält und Objekte beinhaltet, die zum Austausch von Aktivitäten mit einer Fähigkeit verwendet werden. Dazu gehören:

• Ein Skill-Client, der zum Senden von Aktivitäten an einen Skill 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.

C#

JavaScript

Java

Python

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.

C#

SimpleRootBot-\appsettings.jsauf

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"
    }
  ]
}

JavaScript

echo-skill-bot/.env

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/

SkillId=EchoSkillBot
SkillAppId=
SkillEndpoint=http://localhost:39783/api/messages

Java

DialogRootBot\application.properties

Fügen Sie optional die App-ID und das Passwort des Stamm-Bots und die App-ID für den Echo-Skill-Bot zum BotFrameworkSkills-Array hinzu.

Warnung

Es sieht so aus, als ob das gesuchte Beispiel verschoben wurde! Seien Sie sicher, dass wir daran arbeiten, dies zu lösen.

Python

simple_root_bot/config.py

Fügen Sie optional die App-ID und das Passwort des Stamm-Bots und die App-ID für den Echo-Skill-Bot hinzu.

APP_ID = os.environ.get("MicrosoftAppId", "")
APP_PASSWORD = os.environ.get("MicrosoftAppPassword", "")
APP_TYPE = os.environ.get("MicrosoftAppType", "MultiTenant")
APP_TENANTID = os.environ.get("MicrosoftAppTenantId", "")
SKILL_HOST_ENDPOINT = "http://localhost:3978/api/skills"
SKILLS = [
    {
        "id": "EchoSkillBot",
        "app_id": "",
        "skill_endpoint": "http://localhost:39783/api/messages",
    },
]

# Callers to only those specified, '*' allows any caller.

Konfiguration von Qualifikationen

In diesem Beispiel werden Informationen zu den einzelnen Fähigkeiten aus der Konfigurationsdatei in eine Sammlung von Fähigkeit-Objekten eingelesen.

C#

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>();
}

JavaScript

simple-root-bot/skillsConfiguration.js

 * A helper class that loads Skills information from configuration.
 */
class SkillsConfiguration {
    constructor() {
        this.skillsData = {};

        // Note: we only have one skill in this sample but we could load more if needed.
        const botFrameworkSkill = {
            id: process.env.SkillId,
            appId: process.env.SkillAppId,
            skillEndpoint: process.env.SkillEndpoint
        };

        this.skillsData[botFrameworkSkill.id] = botFrameworkSkill;

        this.skillHostEndpointValue = process.env.SkillHostEndpoint;
        if (!this.skillHostEndpointValue) {
            throw new Error('[SkillsConfiguration]: Missing configuration parameter. SkillHostEndpoint is required');
        }
    }

    get skills() {
        return this.skillsData;
    }

    get skillHostEndpoint() {
        return this.skillHostEndpointValue;

Java

DialogRootBot\SkillsConfiguration.java

Warnung

Es sieht so aus, als ob das gesuchte Beispiel verschoben wurde! Seien Sie sicher, dass wir daran arbeiten, dies zu lösen.

Python

simple-root-bot/config.py

SKILLS: Dict[str, BotFrameworkSkill] = {
    skill["id"]: BotFrameworkSkill(**skill) for skill in DefaultConfig.SKILLS
}

Konversations-ID-Factory

Hiermit wird die Konversations-ID für die Nutzung mit der Fertigkeit erstellt, und die ursprüngliche Konversations-ID des Benutzers kann aus der Konversations-ID der Fertigkeit 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.

C#

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.

JavaScript

Das SDK stellt eine SkillConversationIdFactory-Klasse bereit, die über alle Skills hinweg verwendet werden kann, ohne dass der Quellcode repliziert werden muss. Die Konversations-ID-Fabrik ist in index.js konfiguriert.

Java

Java hat die Klasse SkillConversationIdFactory als SDK-Klasse implementiert, die für jeden Skill verwendet werden kann, ohne dass der Quellcode repliziert werden muss. Der Code für SkillConversationIdFactory befindet sich im Botbuilder-Paketquellcode [botbuilder Java SDK-Code].

Python

simple-root-bot/skill_conversation_id_factory.py

class SkillConversationIdFactory(ConversationIdFactoryBase):
    def __init__(self, storage: Storage):
        if not storage:
            raise TypeError("storage can't be None")

        self._storage = storage

    async def create_skill_conversation_id(
        self,
        options_or_conversation_reference: Union[
            SkillConversationIdFactoryOptions, ConversationReference
        ],
    ) -> str:
        if not options_or_conversation_reference:
            raise TypeError("Need options or conversation reference")

        if not isinstance(
            options_or_conversation_reference, SkillConversationIdFactoryOptions
        ):
            raise TypeError(
                "This SkillConversationIdFactory can only handle SkillConversationIdFactoryOptions"
            )

        options = options_or_conversation_reference

        # Create the storage key based on the SkillConversationIdFactoryOptions.
        conversation_reference = TurnContext.get_conversation_reference(
            options.activity
        )
        skill_conversation_id = (
            f"{conversation_reference.conversation.id}"
            f"-{options.bot_framework_skill.id}"
            f"-{conversation_reference.channel_id}"
            f"-skillconvo"
        )

        # Create the SkillConversationReference instance.
        skill_conversation_reference = SkillConversationReference(
            conversation_reference=conversation_reference,
            oauth_scope=options.from_bot_oauth_scope,
        )

        # Store the SkillConversationReference using the skill_conversation_id as a key.
        skill_conversation_info = {skill_conversation_id: skill_conversation_reference}
        await self._storage.write(skill_conversation_info)

        # Return the generated skill_conversation_id (that will be also used as the conversation ID to call the skill).
        return skill_conversation_id

    async def get_conversation_reference(
        self, skill_conversation_id: str
    ) -> Union[SkillConversationReference, ConversationReference]:
        if not skill_conversation_id:
            raise TypeError("skill_conversation_id can't be None")

        # Get the SkillConversationReference from storage for the given skill_conversation_id.
        skill_conversation_info = await self._storage.read([skill_conversation_id])

        return skill_conversation_info.get(skill_conversation_id)

    async def delete_conversation_reference(self, skill_conversation_id: str):
        await self._storage.delete([skill_conversation_id])

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-Anwender verwendet einen Skill-Client, um Aktivitäten an den Skill 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 einem Skill 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.

C#

SimpleRootBot\Startup.cs

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

JavaScript

simple-root-bot/index.js

// is restarted, anything stored in memory will be gone.
const memoryStorage = new MemoryStorage();
const conversationState = new ConversationState(memoryStorage);

// Create the conversationIdFactory

// Route received a request to adapter for processing

Java

DialogRootBot\application.java

Warnung

Es sieht so aus, als ob das gesuchte Beispiel verschoben wurde! Seien Sie sicher, dass wir daran arbeiten, dies zu lösen.

Python

simple-root-bot/app.py

CREDENTIAL_PROVIDER = SimpleCredentialProvider(CONFIG.APP_ID, CONFIG.APP_PASSWORD)
CLIENT = SkillHttpClient(CREDENTIAL_PROVIDER, ID_FACTORY)

    ADAPTER, BOT, ID_FACTORY, CREDENTIAL_PROVIDER, AUTH_CONFIG
)

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.

Der Standard-Skill-Handler:

• 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.

C#

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);
}

JavaScript

simple-root-bot/rootBot.js

Der Stamm-Bot verfügt über Abhängigkeiten in Bezug auf den Konversationszustand, die Qualifikationsinformationen und den Skill-Client. Der Stamm-Bot definiert auch einen Eigenschaftenaccessor für den Konversationszustand, um nachzuverfolgen, welche Qualifikation aktiv ist.

class RootBot extends ActivityHandler {
    constructor(conversationState, skillsConfig, skillClient, conversationIdFactory) {
        super();
        if (!conversationState) throw new Error('[RootBot]: Missing parameter. conversationState is required');
        if (!skillsConfig) throw new Error('[RootBot]: Missing parameter. skillsConfig is required');
        if (!skillClient) throw new Error('[RootBot]: Missing parameter. skillClient is required');
        if (!conversationIdFactory) throw new Error('[RootBot]: Missing parameter. conversationIdFactory is required');

        this.conversationState = conversationState;
        this.skillsConfig = skillsConfig;

this.targetSkill = skillsConfig.skills[targetSkillId];

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.

}

async sendToSkill(context, targetSkill) {
    // NOTE: Always SaveChanges() before calling a skill so that any activity generated by the skill
    // will have access to current accurate state.
    await this.conversationState.saveChanges(context, true);

    // Create a conversationId to interact with the skill and send the activity
    const skillConversationId = await this.conversationIdFactory.createSkillConversationIdWithOptions({
        fromBotOAuthScope: context.turnState.get(context.adapter.OAuthScopeKey),
        fromBotId: this.botId,
        activity: context.activity,
        botFrameworkSkill: this.targetSkill
    });

    // route the activity to the skill
    const response = await this.skillClient.postActivity(this.botId, targetSkill.appId, targetSkill.skillEndpoint, this.skillsConfig.skillHostEndpoint, skillConversationId, context.activity);

    // Check response status
    if (!(response.status >= 200 && response.status <= 299)) {
        throw new Error(`[RootBot]: 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.

});

// See https://aka.ms/about-bot-activity-message to learn more about the message and other activity types.
this.onMessage(async (context, next) => {
    if (context.activity.text.toLowerCase() === 'skill') {
        await context.sendActivity('Got it, connecting you to the skill...');

        // Set active skill
        await this.activeSkillProperty.set(context, this.targetSkill);

        // Send the activity to the skill
        await this.sendToSkill(context, this.targetSkill);
    } else {
        await context.sendActivity("Me no nothin'. Say 'skill' and I'll patch you through");
    }

    // By calling next() you ensure that the next BotHandler is run.
    await next();
});

// Handle EndOfConversation returned by the skill.
this.onEndOfConversation(async (context, next) => {
    // Stop forwarding activities to Skill.
    await this.activeSkillProperty.set(context, undefined);

    // Show status message, text and value returned by the skill
    let eocActivityMessage = `Received ${ ActivityTypes.EndOfConversation }.\n\nCode: ${ context.activity.code }`;
    if (context.activity.text) {
        eocActivityMessage += `\n\nText: ${ context.activity.text }`;
    }

    if (context.activity.value) {
        eocActivityMessage += `\n\nValue: ${ context.activity.value }`;
    }

    await context.sendActivity(eocActivityMessage);

    // We are back at the root
    await context.sendActivity('Back in the root bot. Say \'skill\' and I\'ll patch you through');

    // Save conversation state
    await this.conversationState.saveChanges(context, true);

    // By calling next() you ensure that the next BotHandler is run.

Java

DialogRootBot\RootBot.java

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.

Warnung

Es sieht so aus, als ob das gesuchte Beispiel verschoben wurde! Seien Sie sicher, dass wir daran arbeiten, dies zu lösen.

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.

Warnung

Es sieht so aus, als ob das gesuchte Beispiel verschoben wurde! Seien Sie sicher, dass wir daran arbeiten, dies zu lösen.

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.

Warnung

Es sieht so aus, als ob das gesuchte Beispiel verschoben wurde! Seien Sie sicher, dass wir daran arbeiten, dies zu lösen.

Python

simple-root-bot/bots/root_bot.py

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

def __init__(
    self,
    conversation_state: ConversationState,
    skills_config: SkillConfiguration,
    skill_client: SkillHttpClient,
    config: DefaultConfig,
):
    self._bot_id = config.APP_ID
    self._skill_client = skill_client
    self._skills_config = skills_config
    self._conversation_state = conversation_state
    self._active_skill_property = conversation_state.create_property(
        ACTIVE_SKILL_PROPERTY_NAME
    )

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.

async def __send_to_skill(
    self, turn_context: TurnContext, target_skill: BotFrameworkSkill
):
    # NOTE: Always SaveChanges() before calling a skill so that any activity generated by the skill
    # will have access to current accurate state.
    await self._conversation_state.save_changes(turn_context, force=True)

    # route the activity to the skill
    await self._skill_client.post_activity_to_skill(
        self._bot_id,
        target_skill,
        self._skills_config.SKILL_HOST_ENDPOINT,
        turn_context.activity,
    )

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.

async def on_message_activity(self, turn_context: TurnContext):
    if "skill" in turn_context.activity.text:
        # Begin forwarding Activities to the skill
        await turn_context.send_activity(
            MessageFactory.text("Got it, connecting you to the skill...")
        )

        skill = self._skills_config.SKILLS[TARGET_SKILL_ID]
        # Save active skill in state
        await self._active_skill_property.set(turn_context, skill)

        # Send the activity to the skill
        await self.__send_to_skill(turn_context, skill)
    else:
        # just respond
        await turn_context.send_activity(
            MessageFactory.text(
                "Me no nothin'. Say \"skill\" and I'll patch you through"
            )
        )

async def on_end_of_conversation_activity(self, turn_context: TurnContext):
    # forget skill invocation
    await self._active_skill_property.delete(turn_context)

    eoc_activity_message = f"Received {ActivityTypes.end_of_conversation}.\n\nCode: {turn_context.activity.code}"
    if turn_context.activity.text:
        eoc_activity_message = (
            eoc_activity_message + f"\n\nText: {turn_context.activity.text}"
        )

    if turn_context.activity.value:
        eoc_activity_message = (
            eoc_activity_message + f"\n\nValue: {turn_context.activity.value}"
        )

    await turn_context.send_activity(eoc_activity_message)

    # We are back
    await turn_context.send_activity(
        MessageFactory.text(
            'Back in the root bot. Say "skill" and I\'ll patch you through'
        )
    )

    await self._conversation_state.save_changes(turn_context, force=True)

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.

C#

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}");
    }
}

JavaScript

simple-root-bot/index.js

const botFrameworkAuthentication = new ConfigurationBotFrameworkAuthentication(process.env, credentialsFactory, authConfig);

// Create adapter.
// See https://aka.ms/about-bot-adapter to learn more about how bots work.
const adapter = new CloudAdapter(botFrameworkAuthentication);

// Catch-all for errors.
adapter.onTurnError = async (context, error) => {
    // This check writes out errors to the console log, instead of to app insights.
    // NOTE: In production environment, you should consider logging this to Azure
    //       application insights. See https://aka.ms/bottelemetry for telemetry
    //       configuration instructions.
    console.error(`\n [onTurnError] unhandled error: ${ error }`);

    await sendErrorMessage(context, error);
    await endSkillConversation(context);
    await clearConversationState(context);
};

async function sendErrorMessage(context, error) {
    try {
        // Send a message to the user.
        let onTurnErrorMessage = 'The bot encountered an error or bug.';
        await context.sendActivity(onTurnErrorMessage, onTurnErrorMessage, InputHints.IgnoringInput);

        onTurnErrorMessage = 'To continue to run this bot, please fix the bot source code.';
        await context.sendActivity(onTurnErrorMessage, onTurnErrorMessage, InputHints.ExpectingInput);

        // Send a trace activity, which will be displayed in Bot Framework Emulator.
        await context.sendTraceActivity(
            'OnTurnError Trace',
            `${ error }`,
            'https://www.botframework.com/schemas/error',
            'TurnError'
        );
    } catch (err) {
        console.error(`\n [onTurnError] Exception caught in sendErrorMessage: ${ err }`);
    }
}

async function endSkillConversation(context) {
    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.
        const activeSkill = await conversationState.createProperty(RootBot.ActiveSkillPropertyName).get(context);
        if (activeSkill) {
            const botId = process.env.MicrosoftAppId ?? '';

            let endOfConversation = {
                type: ActivityTypes.EndOfConversation,
                code: 'RootSkillError'
            };
            // @ts-ignore
            endOfConversation = TurnContext.applyConversationReference(
                endOfConversation, TurnContext.getConversationReference(context.activity), true);

            await conversationState.saveChanges(context, true);
            // @ts-ignore
            await skillClient.postActivity(botId, activeSkill.appId, activeSkill.skillEndpoint, skillsConfig.skillHostEndpoint, endOfConversation.conversation.id, endOfConversation);
        }
    } catch (err) {
        console.error(`\n [onTurnError] Exception caught on attempting to send EndOfConversation : ${ err }`);
    }
}

async function clearConversationState(context) {
    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 page.
        await conversationState.delete(context);

Java

DialogRootBot\SkillAdapterWithErrorHandler.java

In diesem Beispiel ist die Durchlauffehlerlogik auf mehrere Hilfsmethoden aufgeteilt.

Warnung

Es sieht so aus, als ob das gesuchte Beispiel verschoben wurde! Seien Sie sicher, dass wir daran arbeiten, dies zu lösen.

Python

simple-root-bot/adapter_with_error_handler.py

    # This check writes out errors to console log
    # NOTE: In production environment, you should consider logging this to Azure
    #       application insights.
    print(f"\n [on_turn_error] unhandled error: {error}", file=sys.stderr)
    traceback.print_exc()
    await self._send_error_message(turn_context, error)
    await self._end_skill_conversation(turn_context, error)
    await self._clear_conversation_state(turn_context)

async def _send_error_message(self, turn_context: TurnContext, error: Exception):
    if not self._skill_client or not self._skill_config:
        return
    try:
        # Send a message to the user.
        error_message_text = "The skill encountered an error or bug."
        error_message = MessageFactory.text(
            error_message_text, error_message_text, InputHints.ignoring_input
        )
        await turn_context.send_activity(error_message)

        error_message_text = (
            "To continue to run this bot, please fix the bot source code."
        )
        error_message = MessageFactory.text(
            error_message_text, error_message_text, InputHints.ignoring_input
        )
        await turn_context.send_activity(error_message)

        # Send a trace activity, which will be displayed in Bot Framework Emulator.
        await turn_context.send_trace_activity(
            label="TurnError",
            name="on_turn_error Trace",
            value=f"{error}",
            value_type="https://www.botframework.com/schemas/error",
        )
    except Exception as exception:
        print(
            f"\n Exception caught on _send_error_message : {exception}",
            file=sys.stderr,
        )
        traceback.print_exc()

async def _end_skill_conversation(
    self, turn_context: TurnContext, error: Exception
):
    if not self._skill_client or not self._skill_config:
        return

    try:
        # Inform the active skill that the conversation is ended so that it has a chance to clean up.
        # Note: the root bot manages the ActiveSkillPropertyName, which has a value while the root bot
        # has an active conversation with a skill.
        active_skill = await self._conversation_state.create_property(
            ACTIVE_SKILL_PROPERTY_NAME
        ).get(turn_context)

        if active_skill:
            bot_id = self._config.APP_ID
            end_of_conversation = Activity(type=ActivityTypes.end_of_conversation)
            end_of_conversation.code = "RootSkillError"
            TurnContext.apply_conversation_reference(
                end_of_conversation,
                TurnContext.get_conversation_reference(turn_context.activity),
                True,
            )

            await self._conversation_state.save_changes(turn_context, True)
            await self._skill_client.post_activity_to_skill(
                bot_id,
                active_skill,
                self._skill_config.SKILL_HOST_ENDPOINT,
                end_of_conversation,
            )
    except Exception as exception:
        print(
            f"\n Exception caught on _end_skill_conversation : {exception}",
            file=sys.stderr,
        )
        traceback.print_exc()

async def _clear_conversation_state(self, turn_context: 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" for a Web page.
        await self._conversation_state.delete(turn_context)
    except Exception as exception:
        print(
            f"\n Exception caught on _clear_conversation_state : {exception}",
            file=sys.stderr,
        )
        traceback.print_exc()

Endpunkt für Qualifikation

Der Bot definiert einen Endpunkt, der eingehende Skill-Aktivitäten an den Skill-Handler des Stamm-Bots weiterleitet.

C#

SimpleRootBot\Controllers\SkillController.cs

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

JavaScript

simple-root-bot/index.js

    // Route received a request to adapter for processing
    await adapter.process(req, res, (context) => bot.run(context));
});

Java

DialogRootBot\Controllers\SkillController.java

Warnung

Es sieht so aus, als ob das gesuchte Beispiel verschoben wurde! Seien Sie sicher, dass wir daran arbeiten, dies zu lösen.

Python

simple-root-bot/app.py

APP.router.add_post("/api/messages", messages)

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.

C#

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
    };
});

JavaScript

simple-root-bot/index.js

const { SkillsConfiguration } = require('./skillsConfiguration');

// Load skills configuration
const skillsConfig = new SkillsConfiguration();

const allowedSkills = Object.values(skillsConfig.skills).map(skill => skill.appId);

const claimsValidators = allowedCallersClaimsValidator(allowedSkills);

// If the MicrosoftAppTenantId is specified in the environment 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.
let validTokenIssuers = [];
const { MicrosoftAppTenantId } = process.env;

if (MicrosoftAppTenantId) {
    // 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 = [
        `${ AuthenticationConstants.ValidTokenIssuerUrlTemplateV1 }${ MicrosoftAppTenantId }/`,
        `${ AuthenticationConstants.ValidTokenIssuerUrlTemplateV2 }${ MicrosoftAppTenantId }/v2.0/`,
        `${ AuthenticationConstants.ValidGovernmentTokenIssuerUrlTemplateV1 }${ MicrosoftAppTenantId }/`,
        `${ AuthenticationConstants.ValidGovernmentTokenIssuerUrlTemplateV2 }${ MicrosoftAppTenantId }/v2.0/`
    ];
}

// Define our authentication configuration.
const authConfig = new AuthenticationConfiguration([], claimsValidators, validTokenIssuers);

const credentialsFactory = new ConfigurationServiceClientCredentialFactory({
    MicrosoftAppId: process.env.MicrosoftAppId,
    MicrosoftAppPassword: process.env.MicrosoftAppPassword,
    MicrosoftAppType: process.env.MicrosoftAppType,
    MicrosoftAppTenantId: process.env.MicrosoftAppTenantId
});

Java

DialogRootBot\Application.java

Warnung

Es sieht so aus, als ob das gesuchte Beispiel verschoben wurde! Seien Sie sicher, dass wir daran arbeiten, dies zu lösen.

Python

simple-root-bot/app.py

# Create adapter.
# See https://aka.ms/about-bot-adapter to learn more about how bots work.
SETTINGS = ConfigurationBotFrameworkAuthentication(
    CONFIG,
    auth_configuration=AUTH_CONFIG,
)

STORAGE = MemoryStorage()
CONVERSATION_STATE = ConversationState(STORAGE)

ID_FACTORY = SkillConversationIdFactory(STORAGE)
CREDENTIAL_PROVIDER = SimpleCredentialProvider(CONFIG.APP_ID, CONFIG.APP_PASSWORD)
CLIENT = SkillHttpClient(CREDENTIAL_PROVIDER, ID_FACTORY)

ADAPTER = AdapterWithErrorHandler(
    SETTINGS, CONFIG, CONVERSATION_STATE, CLIENT, SKILL_CONFIG
)

# Create the Bot
BOT = RootBot(CONVERSATION_STATE, SKILL_CONFIG, CLIENT, CONFIG)

SKILL_HANDLER = SkillHandler(
    ADAPTER, BOT, ID_FACTORY, CREDENTIAL_PROVIDER, AUTH_CONFIG
)


# Listen for incoming requests on /api/messages
async def messages(req: Request) -> Response:
    # Main bot message handler.
    if "application/json" in req.headers["Content-Type"]:
        body = await req.json()
    else:
        return Response(status=HTTPStatus.UNSUPPORTED_MEDIA_TYPE)

    activity = Activity().deserialize(body)
    auth_header = req.headers["Authorization"] if "Authorization" in req.headers else ""

    invoke_response = await ADAPTER.process_activity(auth_header, activity, BOT.on_turn)
    if invoke_response:
        return json_response(data=invoke_response.body, status=invoke_response.status)
    return Response(status=HTTPStatus.OK)

Testen des Stamm-Bots

Sie können den Skill-Consumer im Emulator testen, als wäre er ein normaler Bot; allerdings müssen Sie sowohl den Skill- als auch den Skill-Consumer-Bot gleichzeitig 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, verweisen Sie auf die README-Datei für das Beispiel in C#, JavaScript, Java oder Python.
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 endOfConversation-Eigenschaft der -Aktivität gibt an, dass die Qualifikation erfolgreich abgeschlossen wurde.

Mehr über Debuggen

Da der Datenverkehr zwischen Skills und Skill-Nutzern authentifiziert wird, gibt es zusätzliche Schritte beim Debuggen dieser 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 Root-Bot sollte die Nachricht des Benutzers überprüfen, bevor er sie an die aktive Fähigkeit 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. Um Rückgabewerte vom Skill zu erhalten, sollte der Skill-Consumer die value-Eigenschaft überprüfen, wenn der Skill eine endOfConversation-Aktivität sendet.

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 den Zustellmodus Expect Replies:

• 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.