Share via

Képességfelhasználó megvalósítása

  • Cikk

A KÖVETKEZŐKRE VONATKOZIK: SDK v4

A képességek segítségével kiterjeszthet egy másik robotot. A képesség olyan robot, amely képes feladatokat végrehajtani egy másik robot számára, és egy jegyzék használatával írja le a felületét. A gyökérrobot egy felhasználóval rendelkező robot, amely meghívhat egy vagy több képességet. A gyökérrobot egyfajta készségfelhasználó.

  • A készségfelhasználóknak jogcímérvényesítést kell használniuk annak kezeléséhez, hogy mely készségek férhetnek hozzá.
  • A készségfelhasználók több készséget is használhatnak.
  • Azok a fejlesztők, akik nem férnek hozzá a képesség forráskódjába, a képességjegyzékben szereplő információkat felhasználhatják a képességfelhasználó tervezéséhez.

Ez a cikk bemutatja, hogyan valósíthat meg olyan készségfelhasználót, amely az echo-készséget használja a felhasználó bemenetének visszhangjára. Egy minta készségjegyzékért és az echo-készség megvalósításával kapcsolatos információkért tekintse meg, hogyan valósíthat meg egy készséget.

Ha tudni szeretné, hogyan használhatja fel a készséget egy készséget használó párbeszédpanelen, olvassa el, hogyan használhatja fel a készséget egy párbeszédpanelen.

Bizonyos típusú készségfelhasználók nem tudnak bizonyos típusú képességrobotokat használni. Az alábbi táblázat ismerteti, hogy mely kombinációk támogatottak.

  Több-bérlős képesség Egybérlős képesség Felhasználó által hozzárendelt felügyelt identitástudás
Több-bérlős fogyasztó Támogatott Nem támogatott Nem támogatott
Egybérlős fogyasztó Nem támogatott Támogatott, ha mindkét alkalmazás ugyanahhoz a bérlőhöz tartozik Támogatott, ha mindkét alkalmazás ugyanahhoz a bérlőhöz tartozik
Felhasználó által hozzárendelt felügyelt identitásfelhasználó Nem támogatott Támogatott, ha mindkét alkalmazás ugyanahhoz a bérlőhöz tartozik Támogatott, ha mindkét alkalmazás ugyanahhoz a bérlőhöz tartozik

Feljegyzés

A Bot Framework JavaScript, C# és Python SDK-k továbbra is támogatottak lesznek, a Java SDK-t azonban 2023 novemberében végső hosszú távú támogatással kivonják.

A Java SDK-val létrehozott meglévő robotok továbbra is működni fognak.

Új robotépítéshez fontolja meg a Power Virtual Agents használatát, és olvassa el a megfelelő csevegőrobot-megoldás kiválasztását.

További információ: A robotépítés jövője.

Előfeltételek

Feljegyzés

A 4.11-es verziótól kezdve nincs szükség alkalmazásazonosítóra és -jelszóra egy képességfelhasználó helyi teszteléséhez a Bot Framework Emulatorban. Egy Azure-előfizetésre továbbra is szükség van a fogyasztó Azure-ban való üzembe helyezéséhez vagy egy üzembe helyezett képesség használatához.

A minta ismertetése

Az egyszerű robot-robot minta két robothoz tartozó projekteket tartalmaz:

  • Az echo skill robot, amely megvalósítja a képességet.
  • Az egyszerű gyökérrobot, amely implementál egy gyökérrobotot, amely felhasználja a képességet.

Ez a cikk a gyökérrobotra összpontosít, amely támogatja a robot és az adapter objektumait, és olyan objektumokat is tartalmaz, amelyeket a tevékenységek szakértelemmel való cseréjéhez használnak. Ezek közé tartoznak:

  • Képességügyfél, amellyel tevékenységeket küldhet egy képességnek.
  • Képességkezelő, amely egy képesség tevékenységeinek fogadására szolgál.
  • Egy készségalapú beszélgetés azonosító-előállító, amelyet a képességügyfél és a kezelő használ a felhasználó-gyökér beszélgetés referenciája és a gyökérszintű beszélgetési referencia közötti fordításhoz.

Az Echo skill robottal kapcsolatos információkért tekintse meg, hogyan implementálhat egy készséget.

Források

Az üzembe helyezett robotok esetében a robotok között történő hitelesítéshez minden résztvevő robotnak érvényes identitásadatokra van szüksége. A több-bérlős készségeket és készségeket azonban helyileg tesztelheti az Emulator használatával alkalmazásazonosító és jelszó nélkül.

Alkalmazáskonfiguráció

  1. Szükség esetén adja hozzá a gyökérrobot identitásadatait a konfigurációs fájlhoz. Ha a képesség- vagy képességfelhasználó identitásadatokat ad meg, mindkettőnek meg kell lennie.
  2. Adja hozzá a képességgazda végpontját (a szolgáltatás vagy visszahívási URL-címet), amelyre a készségeknek válaszolniuk kell a képességfelhasználónak.
  3. Adjon hozzá egy bejegyzést minden olyan képességhez, amelyet a készségfelhasználó használni fog. Minden bejegyzés a következőket tartalmazza:
    • Egy azonosító, amellyel a készségfelhasználó azonosítja az egyes képességeket.
    • Igény szerint a képesség alkalmazás- vagy ügyfélazonosítója.
    • A képesség üzenetkezelési végpontja.

Feljegyzés

Ha a képesség- vagy képességfelhasználó identitásadatokat ad meg, mindkettőnek meg kell lennie.

SimpleRootBot\appsettings.json

Ha szükséges, adja hozzá a gyökérrobot identitásadatait, és adja hozzá az echo skill robot alkalmazás- vagy ügyfélazonosítóját.

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

Képességkonfiguráció

Ez a minta a konfigurációs fájl minden egyes képességére vonatkozó információt készségobjektumok gyűjteményébe olvas be.

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

Beszélgetésazonosító-előállító

Ez létrehozza a beszélgetés azonosítóját a képességhez való használatra, és visszaállíthatja az eredeti felhasználói beszélgetési azonosítót a készség-beszélgetés azonosítójából.

A minta beszélgetésazonosító-előállítója egy egyszerű forgatókönyvet támogat, ahol:

  • A gyökérrobotot úgy tervezték, hogy egy adott készséget használjon fel.
  • A gyökérrobotnak egyszerre csak egy aktív beszélgetése van egy szakértelemmel.

Az SDK egy olyan osztályt SkillConversationIdFactory biztosít, amely bármely képességhez használható anélkül, hogy a forráskódot replikálni kellene. A beszélgetésazonosító-előállító Startup.cs van konfigurálva.

Az összetettebb forgatókönyvek támogatásához a beszélgetésazonosító-előállítót úgy tervezheti meg, hogy:

  • A képesség-beszélgetés azonosítójának létrehozása metódus lekéri vagy létrehozza a megfelelő készségbeszélgetés-azonosítót.
  • A beszélgetés lekérése hivatkozási módszer a megfelelő felhasználói beszélgetést kapja meg.

Skill client and skill handler

A készségfelhasználó egy képességügyfél használatával továbbítja a tevékenységeket a képességnek. Az ügyfél ehhez a készségek konfigurációs adatait és a beszélgetésazonosító-előállítót használja.

A készségfelhasználó egy képességkezelővel fogad tevékenységeket egy képességből. A kezelő ehhez a beszélgetésazonosító-előállítót, a hitelesítési konfigurációt és a hitelesítőadat-szolgáltatót használja, valamint függőségekkel rendelkezik a gyökérrobot adapterétől és tevékenységkezelőétől

SimpleRootBot\Startup.cs

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

A képességből származó HTTP-forgalom a szolgáltatás URL-végpontjába kerül, amelyet a képességfelhasználó hirdet a képesség számára. Egy nyelvspecifikus végpontkezelővel továbbítja a forgalmat a képességkezelőnek.

Az alapértelmezett képességkezelő:

  • Ha az alkalmazásazonosító és a jelszó megtalálható, egy hitelesítési konfigurációs objektum használatával hajtja végre a robotok között végzett hitelesítést és a jogcímek érvényesítését.
  • A beszélgetésazonosító-előállító használatával a fogyasztó-készség beszélgetésről a gyökérfelhasználói beszélgetésre fordítható vissza.
  • Proaktív üzenetet hoz létre, hogy a képességfelhasználó újra létrehozhassa a gyökérfelhasználói kontextust, és továbbíthassa a tevékenységeket a felhasználónak.

Tevékenységkezelő logika

Fontos megjegyezni, hogy a készségfogyás logikájának a következőnek kell lennie:

  • Ne feledje, hogy vannak-e aktív készségek, és szükség szerint továbbítsa őket.
  • Figyelje meg, ha egy felhasználó olyan kérést küld, amelyet továbbítani kell egy képességnek, és elindítja a képességet.
  • Keressen egy endOfConversation tevékenységet bármilyen aktív képességből, hogy észrevehesse, mikor fejeződik be.
  • Szükség esetén adjon hozzá logikát, hogy a felhasználó vagy a képességfelhasználó megszakítsa a még nem befejezett készséget.
  • Mentse az állapotot a képesség hívása előtt, mivel a válasz visszajöhet a képességfelhasználó egy másik példányára.

SimpleRootBot\Bots\RootBot.cs

A gyökérrobot függőségeket tartalmaz a beszélgetési állapottól, a készségek információitól, a képességügyfélétől és az általános konfigurációtól. ASP.NET függőséginjektálással biztosítja ezeket az objektumokat. A gyökérrobot egy beszélgetés állapottulajdonság-tartozékot is meghatároz, amely nyomon követi, hogy melyik képesség aktív.

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

Ez a minta egy segédmetódussal rendelkezik a tevékenységek képességhez való továbbításához. A képesség meghívása előtt menti a beszélgetés állapotát, és ellenőrzi, hogy a HTTP-kérés sikeres volt-e.

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

Fontos megjegyezni, hogy a gyökérrobot logikával továbbítja a tevékenységeket a képességnek, elindítja a képességet a felhasználó kérésére, és leállítja a képességet, amikor a képesség befejeződik.

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

Bekapcsolt hibakezelő

Hiba esetén az adapter törli a beszélgetés állapotát a felhasználóval folytatott beszélgetés alaphelyzetbe állításához, és elkerüli a hibaállapot megőrzését.

Ajánlott a beszélgetési tevékenység befejezését bármely aktív képességnek elküldeni, mielőtt törli a beszélgetés állapotát a készségfelhasználóban. Ez lehetővé teszi, hogy a képesség felszabadítsa a fogyasztó-készség beszélgetéshez kapcsolódó erőforrásokat, mielőtt a készségfelhasználó felengedi a beszélgetést.

SimpleRootBot\AdapterWithErrorHandler.cs

Ebben a példában a turn hibalogika fel van osztva néhány segítő módszer között.

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

Készségek végpontja

A robot meghatároz egy végpontot, amely a bejövő készségtevékenységeket továbbítja a gyökérrobot képességkezelőjének.

SimpleRootBot\Controllers\SkillController.cs

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

Szolgáltatásregisztráció

Adjon meg egy hitelesítési konfigurációs objektumot minden jogcím-ellenőrzéssel, valamint az összes további objektummal együtt. Ez a minta ugyanazt a hitelesítési konfigurációs logikát használja a felhasználók és a készségek tevékenységeinek ellenőrzéséhez.

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

A gyökérrobot tesztelése

Tesztelheti a készségfelhasználót az Emulátorban, mintha normál robot lenne; azonban egyszerre kell futtatnia a készség- és készségfelhasználó robotokat is. Megtudhatja, hogyan valósíthat meg készséget a képesség konfigurálására vonatkozó információkhoz.

Töltse le és telepítse a legújabb Bot Framework Emulatort

  1. Futtassa az echo skill robotot és az egyszerű gyökérrobotot helyben a gépen. Ha útmutatásra van szüksége, tekintse meg a README C#, JavaScript, Java vagy Python mintafájlt.
  2. Az Emulator használatával tesztelje a robotot az alább látható módon. Amikor egy vagy stop több end üzenetet küld a képességnek, a képesség a válaszüzenet mellett egy endOfConversation tevékenységet is küld a gyökérrobotnak. A endOfConversation tevékenység kódtulajdonság azt jelzi, hogy a képesség sikeresen befejeződött.

Példa átirat a képességfelhasználóval való interakcióról.

További információ a hibakeresésről

Mivel a készségek és a készségfelhasználók közötti forgalom hitelesítése megtörtént, az ilyen robotok hibakereséséhez további lépések is szükségesek.

Ellenkező esetben ugyanúgy hibakeresést végezhet egy képességfelhasználón vagy képességen, mint más robotok. További információ: Robot hibakeresése és hibakeresés a Bot Framework Emulator használatával.

További információk

Íme néhány megfontolandó szempont egy összetettebb gyökérrobot implementálásakor.

Többlépéses képesség megszakításának engedélyezése a felhasználó számára

A gyökérrobotnak ellenőriznie kell a felhasználó üzenetét, mielőtt továbbítanák azt az aktív képességhez. Ha a felhasználó megszakítja az aktuális folyamatot, a gyökérrobot az üzenet továbbítása helyett egy tevékenységet küldhet endOfConversation a képességnek.

Adatok cseréje a gyökér- és képességrobotok között

Ha paramétereket szeretne küldeni a képességnek, a készségfelhasználó beállíthatja az értéktulajdonságot a képességnek küldött üzeneteken. Ahhoz, hogy visszaadott értékeket kapjon a képességtől, a készségfelhasználónak ellenőriznie kell az értéktulajdonságot , amikor a képesség egy tevékenységet küld endOfConversation .

Több készség használata

  • Ha egy képesség aktív, a gyökérrobotnak meg kell határoznia, hogy melyik képesség aktív, és továbbítania kell a felhasználó üzenetét a megfelelő képességhez.
  • Ha nincs aktív képesség, a gyökérrobotnak meg kell határoznia, hogy a robot állapota és a felhasználó bemenete alapján melyik készséget kell elindítania, ha van ilyen.
  • Ha engedélyezni szeretné a felhasználónak, hogy több egyidejű képesség között váltson, a gyökérrobotnak meg kell határoznia, hogy a felhasználó milyen aktív készségekkel kíván kommunikálni a felhasználó üzenetének továbbítása előtt.

A várt válaszok kézbesítési módjának használata

A várt válaszkézbesítési mód használata:

  • Klónozza a tevékenységet a turn környezetből.
  • Állítsa az új tevékenység kézbesítési módjának tulajdonságát "ExpectReplies" értékre, mielőtt a tevékenységet a gyökérrobotból a szakértelembe küldené.
  • Olvassa el a kérés válaszából visszaadott meghívási válasz törzsének várt válaszait.
  • Dolgozza fel az egyes tevékenységeket a gyökérroboton belül, vagy küldje el az eredeti kérést kezdeményező csatornának.

A válaszokra való várakozás hasznos lehet olyan helyzetekben, amikor a tevékenységre válaszoló robotnak a tevékenységre adott robot ugyanazon példányának kell lennie, amely megkapta a tevékenységet.