Een vaardigheidsconsumer implementeren

VAN TOEPASSING OP: SDK v4

U kunt vaardigheden inzetten om een andere bot verder te ontwikkelen. Een vaardigheid is een bot die een set taken voor een andere bot kan uitvoeren en een manifest gebruikt om de interface ervan te beschrijven. Een hoofdbot is een gebruikersgerichte bot die een of meer vaardigheden kan aanroepen. Een rootbot is een type vaardigheidsgebruiker.

• Een consument van vaardigheden moet claimvalidatie gebruiken om te beheren welke vaardigheden er toegang toe hebben.
• Een vaardigheidsconsumer kan meerdere vaardigheden gebruiken.
• Ontwikkelaars die geen toegang hebben tot de broncode van de vaardigheid, kunnen de informatie in het manifest van de vaardigheid gebruiken om hun vaardigheidsgebruiker te ontwerpen.

In dit artikel wordt gedemonstreerd hoe u een vaardigheidsgebruiker implementeert die gebruik maakt van de echovaardigheid om de invoer van de gebruiker te herhalen. Zie hoe u een vaardigheid implementeert voor een voorbeeldmanifest en informatie over het implementeren van de echovaardigheid.

Voor informatie over het gebruik van een vaardigheidsdialoogvenster om een vaardigheid te gebruiken, raadpleegt u hoe u een dialoogvenster gebruikt om een vaardigheid te gebruiken.

Sommige typen vaardigheidsgebruikers kunnen bepaalde typen vaardigheidsbots niet gebruiken. In de volgende tabel wordt beschreven welke combinaties worden ondersteund.

	Vaardigheid voor meerdere tenants	Vaardigheid met één tenant	Door de gebruiker toegewezen vaardigheden voor beheerde identiteit
Consument met meerdere tenants	Ondersteund	Niet ondersteund	Niet ondersteund
Consument met één tenant	Niet ondersteund	Ondersteund als beide apps deel uitmaken van dezelfde tenant	Ondersteund als beide apps deel uitmaken van dezelfde tenant
Door de gebruiker toegewezen beheerde identiteitgebruiker	Niet ondersteund	Ondersteund als beide apps deel uitmaken van dezelfde tenant	Ondersteund als beide apps deel uitmaken van dezelfde tenant

Notitie

De Sdk's voor Bot Framework JavaScript, C# en Python blijven ondersteund, maar de Java SDK wordt buiten gebruik gesteld met definitieve langetermijnondersteuning die eindigt op november 2023.

Bestaande bots die zijn gebouwd met de Java SDK blijven functioneren.

Voor het bouwen van nieuwe bots kunt u Microsoft Copilot Studio gebruiken en lezen over het kiezen van de juiste copilot-oplossing.

Zie De toekomst van botbouw voor meer informatie.

Vereisten

• Kennis van de basisbeginselen van bots, hoe vaardigheden bots werken en hoe u een vaardigheid implementeert.
• Optioneel, een Azure-abonnement. Als u nog geen abonnement hebt, maakt u een gratis account voordat u begint.
• Een kopie van het eenvoudige bot-naar-bot-voorbeeld in C#, JavaScript, Java of Python.

Notitie

Vanaf versie 4.11 hebt u geen app-id en wachtwoord nodig om een vaardigheidsconsumer lokaal te testen in de Bot Framework Emulator. Een Azure-abonnement is nog steeds vereist om uw consument te implementeren in Azure of om een geïmplementeerde vaardigheid te gebruiken.

Over dit voorbeeld

Het skills eenvoudige bot-naar-bot-voorbeeld bevat projecten voor twee bots:

• De bot met echovaardigheden, waarmee de vaardigheid wordt geïmplementeerd.
• De eenvoudige rootbot, waarmee een rootbot wordt geïmplementeerd die de vaardigheid benut.

Dit artikel focust op de root bot, die ondersteuningslogica bevat in zowel de bot- als adapterobjecten, en bevat objecten die worden gebruikt om activiteiten uit te wisselen met een vaardigheid. Deze omvatten:

• Een vaardigheidsclient, die wordt gebruikt om activiteiten naar een vaardigheid te verzenden.
• Een vaardigheidsverwerker, die wordt gebruikt om activiteiten van een vaardigheid te ontvangen.
• Een vaardigheidsgesprek-ID fabriek, gebruikt door de vaardigheidsclient en verwerker om te vertalen tussen de gebruikergespreksverwijzing en de basisvaardigheidsgespreksverwijzing.

C#

JavaScript

Java

Python

Zie hoe u een vaardigheid implementeert voor informatie over de bot met echovaardigheden.

Middelen

Voor geïmplementeerde bots vereist bot-tot-bot-authenticatie dat elke deelnemende bot geldige identiteitsgegevens heeft. U kunt echter multi-tenant vaardigheden en vaardigheidsgebruikers lokaal testen met de Emulator zonder app-id en wachtwoord.

Toepassingsconfiguratie

1. Voeg eventueel de identiteitsgegevens van de root-bot toe aan zijn configuratiebestand. Als zowel de vaardigheid als de gebruiker identiteitsinformatie verstrekt, moeten beiden dat doen.
2. Voeg het hosteindpunt voor vaardigheden (de service- of callback-URL) toe waaraan de vaardigheden moeten reageren op de vaardigheidsgebruiker.
3. Voeg een vermelding toe voor elke vaardigheid die de consument gaat gebruiken. Elke vermelding omvat:
   • Een id die de consument gebruikt om elke vaardigheid te identificeren.
   • Optioneel: de app- of client-ID van de skill.
   • Het communicatie-eindpunt van de functie.

Notitie

Als de vaardigheid of de gebruiker van de vaardigheid identiteitsinformatie verstrekt, moeten beiden dat doen.

C#

SimpleRootBot\appsettings.json

Voeg eventueel de identiteitsgegevens van de hoofdbot toe en voeg de app- of client-id voor de bot met echovaardigheden toe.

{
  "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

Voeg eventueel de identiteitsgegevens van de root-bot toe. Voeg de app- of client-ID voor de echobot toe.

MicrosoftAppType=
MicrosoftAppId=
MicrosoftAppPassword=
MicrosoftAppTenantId=
SkillHostEndpoint=http://localhost:3978/api/skills/

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

Java

DialogRootBot\application.properties

Voeg eventueel de app-ID en het wachtwoord van de rootbot toe en voeg de app-ID voor de bot met echovaardigheden toe aan de BotFrameworkSkills array.

Waarschuwing

Het lijkt erop dat het voorbeeld dat u zoekt, is verplaatst. Wees gerust dat we aan het oplossen hiervan werken.

Python

simple_root_bot/config.py

Voeg eventueel de app-ID en het wachtwoord van de hoofdbot toe en voeg de app-ID voor de echo skill bot toe.

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.

Vaardighedenconfiguratie

In dit voorbeeld wordt informatie voor elke vaardigheid in het configuratiebestand gelezen in een verzameling vaardigheidsobjecten .

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

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

Waarschuwing

Het lijkt erop dat het voorbeeld dat u zoekt, is verplaatst. Wees gerust dat we aan het oplossen hiervan werken.

Python

simple-root-bot/config.py

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

Gespreks-ID fabriek

Hiermee wordt de gespreks-id voor gebruik met de vaardigheid aangemaakt, en kan de oorspronkelijke gespreks-id van de gebruiker worden hersteld uit de gespreks-id van de vaardigheid.

De gespreks-id factory voor dit voorbeeld ondersteunt een eenvoudig scenario waarbij:

• De hoofdbot is ontworpen om één specifieke vaardigheid te gebruiken.
• De hoofdbot heeft maar één actief gesprek met een vaardigheid tegelijk.

C#

De SDK biedt een SkillConversationIdFactory klasse die kan worden gebruikt voor elke vaardigheid zonder dat de broncode hoeft te worden gerepliceerd. De gespreks-ID-fabriek is geconfigureerd in Startup.cs.

JavaScript

De SDK biedt een SkillConversationIdFactory klasse die kan worden gebruikt voor elke vaardigheid zonder dat de broncode hoeft te worden gerepliceerd. De gespreks-id fabriek is geconfigureerd in index.js.

Java

Java heeft de klasse SkillConversationIdFactory geïmplementeerd als een SDK-klasse die kan worden gebruikt in elke vaardigheid zonder dat de broncode hoeft te worden gerepliceerd. De code voor SkillConversationIdFactory vindt u in de broncode van het botbuilder-pakket [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])

Als u complexere scenario's wilt ondersteunen, ontwerpt u uw gespreks-id factory zodat:

• Met de methode voor het creëren van gespreks-id's voor vaardigheden wordt de juiste gespreks-id voor vaardigheden opgehaald of gegenereerd.
• De get-gespreksreferentie-methode haalt het juiste gebruikersgesprek op.

Vaardigheidsclient en vaardigheidsverwerker

De gebruiker van de vaardigheid gebruikt een vaardigheidsclient om activiteiten door te sturen naar de vaardigheid. De client gebruikt hiervoor de informatie over de configuratie van vaardigheden en gespreks-id's.

De vaardigheidsgebruiker gebruikt een vaardigheidsbeheerder om activiteiten van een vaardigheid te ontvangen. De handler maakt gebruik van de gespreks-ID-fabriek, de verificatieconfiguratie en een referentieverschaffer om dit te doen, en heeft ook afhankelijkheden van de adapter en de activiteitshandler van de hoofdbot.

C#

SimpleRootBot\Startup.cs

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

JavaScript

simple-root-bot/index.js

// Create the conversationIdFactory
const conversationIdFactory = new SkillConversationIdFactory(new MemoryStorage());

// Create the skill client.
const skillClient = botFrameworkAuthentication.createBotFrameworkClient();

const handler = new CloudSkillHandler(adapter, (context) => bot.run(context), conversationIdFactory, botFrameworkAuthentication);

Java

DialogRootBot\application.java

Waarschuwing

Het lijkt erop dat het voorbeeld dat u zoekt, is verplaatst. Wees gerust dat we aan het oplossen hiervan werken.

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
)

HTTP-verkeer van de skill komt binnen op het service-URL-eindpunt dat de gebruiker doorgeeft aan de skill. Gebruik een taalspecifieke eindpunthandler om verkeer door te sturen naar de vaardigheidshandler.

De standaardhandler voor vaardigheden:

• Als er een app-id en wachtwoord aanwezig zijn, gebruikt u een verificatieconfiguratieobject om zowel bot-naar-bot-verificatie als claimvalidatie uit te voeren.
• Gebruikt de gespreks-ID-fabriek om te vertalen van het consument-skills-gesprek terug naar het hoofdgebruiker-gesprek.
• Genereert een proactief bericht zodat de gebruiker van de vaardigheid de root-gebruikercontext kan herstellen en activiteiten naar de gebruiker kan doorsturen.

Logica voor activiteitenbeheerder

Opmerking: de logica van de verbruiker met betrekking tot vaardigheden moet:

• Onthoud of er actieve vaardigheden zijn en stuur indien van toepassing activiteiten naar hen door.
• U merkt op wanneer een gebruiker een verzoek doet dat moet worden doorgestuurd naar een vaardigheid, en start vervolgens de vaardigheid.
• Zoek naar een endOfConversation activiteit van elke actieve vaardigheid om te zien wanneer deze is voltooid.
• Voeg indien van toepassing logica toe om de gebruiker of gebruiker van vaardigheden een vaardigheid te laten annuleren die nog niet is voltooid.
• Sla de status op voordat u de aanroep naar een vaardigheid maakt, omdat elk antwoord kan terugkeren naar een ander exemplaar van de vaardigheidsgebruiker.

C#

SimpleRootBot\Bots\RootBot.cs

De hoofdbot heeft afhankelijkheden van de gespreksstatus, de informatie over competenties, de competentieclient en de algemene configuratie. ASP.NET biedt deze objecten via afhankelijkheidsinjectie. De hoofdbot definieert ook een gespreksstatus-eigenschapstoegang om bij te houden welke vaardigheid actief is.

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

Dit voorbeeld heeft een helpermethode voor het doorsturen van activiteiten naar een vaardigheid. Hiermee wordt de gespreksstatus opgeslagen voordat de vaardigheid wordt aangeroepen en wordt gecontroleerd of de HTTP-aanvraag is geslaagd.

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

Opmerking: de hoofdbot bevat logica voor het doorsturen van activiteiten naar de vaardigheid, het starten van de vaardigheid op verzoek van de gebruiker en het stoppen van de vaardigheid wanneer deze is voltooid.

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

De hoofdbot heeft afhankelijkheden van de gespreksstatus, de informatie over vaardigheden en de vaardigheidsclient. De hoofdbot definieert ook een gespreksstatus-eigenschapstoegang om bij te houden welke vaardigheid actief is.

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.skillClient = skillClient;
    this.conversationIdFactory = conversationIdFactory;

// Create state property to track the active skill
this.activeSkillProperty = this.conversationState.createProperty(RootBot.ActiveSkillPropertyName);

Dit voorbeeld heeft een helpermethode voor het verzenden van activiteiten naar een functie. Hiermee wordt de gespreksstatus opgeslagen voordat de vaardigheid wordt aangeroepen en wordt gecontroleerd of de HTTP-aanvraag is geslaagd.

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

Merk op dat de hoofdbot logica bevat voor het doorsturen van activiteiten naar de vaardigheid, het starten van de vaardigheid op verzoek van de gebruiker en het stoppen van de vaardigheid wanneer de vaardigheid is afgerond.

// 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.
    await next();
});

Java

DialogRootBot\RootBot.java

De basisbot is afhankelijk van de gespreksstatus, de vaardigheidsinformatie, de skill-client en de algemene configuratie. ASP.NET biedt deze objecten via afhankelijkheidsinjectie. De hoofdbot definieert ook een eigenschapstoegangsmiddel voor de gespreksstatus om bij te houden welke vaardigheid momenteel actief is.

Waarschuwing

Het lijkt erop dat het voorbeeld dat u zoekt, is verplaatst. Wees gerust dat we aan het oplossen hiervan werken.

Dit voorbeeld bevat een helpermethode voor het doorsturen van activiteiten naar een skill. Hiermee wordt de gespreksstatus opgeslagen voordat de vaardigheid wordt aangeroepen en wordt gecontroleerd of de HTTP-aanvraag is geslaagd.

Waarschuwing

Het lijkt erop dat het voorbeeld dat u zoekt, is verplaatst. Wees gerust dat we aan het oplossen hiervan werken.

Opmerking: de hoofdbot bevat logica voor het doorsturen van activiteiten naar de vaardigheid, het starten van de vaardigheid op verzoek van de gebruiker en het stoppen van de vaardigheid zodra deze is voltooid.

Waarschuwing

Het lijkt erop dat het voorbeeld dat u zoekt, is verplaatst. Wees gerust dat we aan het oplossen hiervan werken.

Python

simple-root-bot/bots/root_bot.py

De rootbot is afhankelijk van gespreksstatussen, de informatie over vaardigheden, de skillclient en de algemene configuratie. De hoofdbot definieert ook een toegangsbeheerobject voor gespreksstatus om bij te houden welke vaardigheid actief is.

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
    )

Dit voorbeeld heeft een helpermethode voor het doorsturen van activiteiten naar een functie. Hiermee wordt de gespreksstatus opgeslagen voordat de vaardigheid wordt aangeroepen en wordt gecontroleerd of de HTTP-aanvraag is geslaagd.

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,
    )

Opmerking: de hoofdbot bevat logica voor het doorsturen van activiteiten naar de vaardigheid, het starten van de vaardigheid bij de aanvraag van de gebruiker en het stoppen van de vaardigheid wanneer de vaardigheid is voltooid.

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)

Fouthandler inschakelen

Wanneer er een fout optreedt, wist de adapter de gespreksstatus om het gesprek opnieuw in te stellen met de gebruiker en te voorkomen dat een foutstatus behouden blijft.

Het is een goede gewoonte om een einde aan het gesprek te sturen naar elke actieve skill voordat de gespreksstatus in de gebruikersapplicatie wordt gewist. Hiermee kan de vaardigheid alle resources vrijgeven die zijn gekoppeld aan het gesprek over consumentenvaardigheden voordat de consument van de vaardigheid het gesprek vrijgeeft.

C#

SimpleRootBot\AdapterWithErrorHandler.cs

In dit voorbeeld wordt de logica voor turnfouten opgesplitst in een aantal helpermethoden.

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

// 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'
            };
            endOfConversation = TurnContext.applyConversationReference(
                endOfConversation, TurnContext.getConversationReference(context.activity), true);

            await conversationState.saveChanges(context, true);
            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);
    } catch (err) {
        console.error(`\n [onTurnError] Exception caught on attempting to Delete ConversationState : ${ err }`);
    }
}

Java

DialogRootBot\SkillAdapterWithErrorHandler.java

In dit voorbeeld wordt de logica voor turnfouten opgesplitst in een aantal helpermethoden.

Waarschuwing

Het lijkt erop dat het voorbeeld dat u zoekt, is verplaatst. Wees gerust dat we aan het oplossen hiervan werken.

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

Eindpunt voor vaardigheden

De bot definieert een eindpunt dat binnenkomende vaardigheidsactiviteiten doorstuurt naar de vaardigheidshandler van de hoofdbot.

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

const handler = new CloudSkillHandler(adapter, (context) => bot.run(context), conversationIdFactory, botFrameworkAuthentication);
const skillEndpoint = new ChannelServiceRoutes(handler);
skillEndpoint.register(server, '/api/skills');

Java

DialogRootBot\Controllers\SkillController.java

Waarschuwing

Het lijkt erop dat het voorbeeld dat u zoekt, is verplaatst. Wees gerust dat we aan het oplossen hiervan werken.

Python

simple-root-bot/app.py

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

Serviceregistratie

Neem een configuratieobject voor authenticatie op met claimsvalidatie en alle aanvullende objecten. In dit voorbeeld wordt dezelfde verificatieconfiguratielogica gebruikt voor het valideren van activiteiten van zowel gebruikers als vaardigheden.

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

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

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

Java

DialogRootBot\Application.java

Waarschuwing

Het lijkt erop dat het voorbeeld dat u zoekt, is verplaatst. Wees gerust dat we aan het oplossen hiervan werken.

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)

De basisbot testen

U kunt de skill consumer in de emulator testen alsof het een normale bot is; U moet echter tegelijkertijd zowel de vaardigheidsbot als de skill consumer bots uitvoeren. Lees hoe u een vaardigheid implementeert voor informatie over het configureren van de vaardigheid.

De nieuwste Bot Framework Emulator downloaden en installeren

1. Voer de echo-bot en de simpele basisbot lokaal uit op uw computer. Als u instructies nodig hebt, raadpleegt u het bestand voor het READMEC#-, JavaScript-, Java- of Python-voorbeeld.
2. Gebruik de emulator om de bot te testen zoals hieronder wordt weergegeven. Wanneer u een end of stop bericht naar de vaardigheid verzendt, stuurt de vaardigheid naast het antwoordbericht een endOfConversation activiteit naar de hoofdbot. De endOfConversation activiteit's code-eigenschap geeft aan dat de taak succesvol is voltooid.

Meer informatie over foutopsporing

Omdat verkeer tussen vaardigheden en vaardigheidsgebruikers wordt geverifieerd, zijn er extra stappen bij het opsporen van fouten in dergelijke bots.

• De consument van vaardigheden en alle vaardigheden die het direct of indirect gebruikt, moeten actief zijn.
• Als de bots lokaal worden uitgevoerd en als een van de bots een app-id en wachtwoord heeft, moeten alle bots geldige id's en wachtwoorden hebben.
• Als de bots allemaal zijn geïmplementeerd, raadpleegt u hoe u fouten in een bot kunt opsporen vanuit een kanaal met behulp van devtunnel.
• Als sommige bots lokaal draaien en sommige zijn gedeployed, raadpleeg dan hoe je fouten kunt opsporen in een vaardigheid of vaardigheidsgebruiker.

Anders kunt u een vaardigheidsgebruiker of vaardigheid debuggen, net zoals bij het opsporen van fouten in andere bots. Zie Fouten opsporen in een bot en fouten opsporen met de Bot Framework Emulator voor meer informatie.

Aanvullende informatie

Hier volgen enkele aandachtspunten bij het implementeren van een complexere hoofdbot.

De gebruiker toestaan een vaardigheid met meerdere stappen te annuleren

De root bot moet het bericht van de gebruiker controleren voordat het naar de actieve skill wordt doorgestuurd. Als de gebruiker het huidige proces wil annuleren, kan de hoofdbot een endOfConversation activiteit naar de vaardigheid verzenden in plaats van het bericht door te sturen.

Gegevens uitwisselen tussen de basis- en vaardigheidsbots

Als u parameters naar de skill wilt verzenden, kan de gebruiker van de skill de waarde-eigenschap instellen voor berichten die naar de skill worden verzonden. Als u retourwaarden van de vaardigheid wilt ontvangen, moet de gebruiker van de vaardigheid de waarde-eigenschap controleren wanneer de vaardigheid een endOfConversation activiteit verzendt.

Meerdere vaardigheden gebruiken

• Als een vaardigheid actief is, moet de hoofdbot bepalen welke vaardigheid actief is en het bericht van de gebruiker doorsturen naar de juiste vaardigheid.
• Als er geen vaardigheid actief is, moet de hoofdbot bepalen welke vaardigheid moet worden gestart, indien van toepassing, op basis van de botstatus en de invoer van de gebruiker.
• Als u wilt dat de gebruiker moet kunnen schakelen tussen meerdere gelijktijdige vaardigheden, moet de hoofdbot bepalen met welke van de actieve vaardigheden de gebruiker wil communiceren, voordat het bericht van de gebruiker wordt doorgestuurd.

Een bezorgingsmodus van verwachte antwoorden gebruiken

Ga als volgt te werk om de modus voor beantwoording verwachten te gebruiken:

• Kloon de activiteit vanuit de turncontext.
• Stel de eigenschap leveringsmodus van de nieuwe activiteit in op 'ExpectReplies' voordat u de activiteit van de root bot naar de Skill verzendt.
• Lees verwachte antwoorden uit de hoofdtekst van de aanroeprespons die is geretourneerd door de aanvraag.
• Verwerkt elke activiteit, binnen de hoofdbot of door deze naar het kanaal te verzenden dat de oorspronkelijke aanvraag heeft gestart.

U kunt verwachten dat antwoorden nuttig kunnen zijn in situaties waarin de bot die antwoordt op een activiteit hetzelfde exemplaar moet zijn van de bot die de activiteit heeft ontvangen.