Compartir a través de

Implementación de un consumidor de aptitudes

  • Artículo

SE APLICA A: SDK v4

Puede usar las aptitudes para ampliar otro bot. Una aptitud es un bot que puede realizar un conjunto de tareas para otro bot y que usa un manifiesto para describir su interfaz. Un bot raíz es un bot accesible para el usuario que puede invocar a una o más aptitudes. Un bot raíz es un tipo de consumidor de aptitudes.

  • Un consumidor de aptitudes debe usar la validación de notificaciones para administrar qué aptitudes pueden tener acceso a él.
  • Un consumidor de aptitudes puede utilizar varias aptitudes.
  • Los desarrolladores que no tienen acceso al código fuente de la aptitud pueden usar la información del manifiesto de la aptitud para diseñar su consumidor de aptitudes.

En este artículo se muestra cómo implementar un consumidor de aptitudes que usa la aptitud de eco para repetir los datos de entrada del usuario. Para ver un ejemplo de un manifiesto de aptitud e información sobre cómo implementar la aptitud de eco, consulte cómo implementar una aptitud.

Para más información sobre el uso de un diálogo de aptitudes para consumir una aptitud, consulte cómo usar un diálogo para consumir una aptitud.

Algunos tipos de consumidores de aptitudes no pueden usar algunos tipos de bots de aptitudes. Las combinaciones admitidas se describen en la tabla siguiente.

  Aptitud multiinquilino Habilidad de un inquilino único Aptitud de identidad administrada asignada por el usuario
Consumidor multiinquilino Compatible No compatible No compatible
Consumidor de un solo inquilino No compatible Se admite si ambas aplicaciones pertenecen al mismo inquilino Se admite si ambas aplicaciones pertenecen al mismo inquilino
Consumidor de la identidad administrada asignada por el usuario No compatible Se admite si ambas aplicaciones pertenecen al mismo inquilino Se admite si ambas aplicaciones pertenecen al mismo inquilino

Nota:

Los SDK de JavaScript, C# y Python de Bot Framework seguirán siendo compatibles, pero el SDK de Java se va a retirar con la compatibilidad final a largo plazo que finaliza en noviembre de 2023.

Los bots existentes creados con el SDK de Java seguirán funcionando.

Para la nueva compilación de bots, considere la posibilidad de usar Microsoft Copilot Studio y lea sobre cómo elegir la solución de copilot adecuada.

Para obtener más información, consulta El futuro de la creación de bots.

Requisitos previos

Nota:

A partir de la versión 4.11, no necesita un identificador de aplicación ni una contraseña para probar un consumidor de aptitudes localmente en Bot Framework Emulator. Una suscripción de Azure sigue siendo necesaria para implementar el consumidor en Azure o para consumir una aptitud implementada.

Acerca de este ejemplo

El ejemplo skills simple bot-to-bot incluye proyectos para dos bots:

  • El bot de aptitud de eco, que implementa la aptitud.
  • El bot raíz simple, que implementa un bot raíz que utiliza la aptitud.

Este artículo se centra en el bot raíz, que incluye la lógica subyacente en sus objetos de bot y adaptador, e incluye los objetos que se usan para intercambiar actividades con una aptitud. Entre ellas se incluyen las siguientes:

  • Un cliente de aptitudes, que se usa para enviar actividades a una aptitud.
  • Un controlador de aptitudes, que se usa para recibir actividades de una aptitud.
  • Un generador de identificadores de conversación de aptitudes, que el cliente y el controlador de aptitudes utilizan para traducir de la referencia de la conversación entre el bot raíz y el usuario a la referencia de la conversación entre el bot raíz y la aptitud, y viceversa.

Para más información sobre el bot de aptitud de eco, consulte cómo implementar una aptitud.

Recursos

Para los bots implementados, la autenticación de bot a bot requiere que cada bot participante tenga información de identidad válida. Sin embargo, puede probar las aptitudes multiinquilino y los consumidores de aptitudes localmente con Emulator sin un identificador de aplicación y una contraseña.

Configuración de aplicaciones

  1. Opcionalmente, agregue la información de identidad del bot raíz al archivo de configuración. Si el consumidor de aptitudes o aptitudes proporciona información de identidad, ambos deben proporcionarla.
  2. Agregue el punto de conexión del host de aptitudes (el servicio o la URL de devolución de llamada) al que las habilidades deben responder al consumidor de aptitudes.
  3. Agregue una entrada para cada aptitud que usará el consumidor de aptitudes. Cada entrada incluye:
    • Un identificador que el consumidor de aptitudes usará para identificar cada aptitud.
    • Opcionalmente, la aplicación o el identificador de cliente de la aptitud.
    • El punto de conexión de mensajería de la aptitud.

Nota:

Si el consumidor de aptitudes o aptitudes proporciona información de identidad, ambos deben proporcionarla.

SimpleRootBot\appsettings.json

Opcionalmente, agregue la información de identidad del bot raíz y agregue la aplicación o el identificador de cliente para el bot de aptitud de eco.

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

Configuración de aptitudes

En este ejemplo, se lee la información de cada aptitud del archivo de configuración en una colección de objetos skill.

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

Generador de identificadores de conversación

Crea el identificador de conversación que se va a usar con la aptitud y puede recuperar el identificador de la conversación original con el usuario a partir del identificador de la conversación con la aptitud.

En este ejemplo, el generador de identificadores de conversación admite un escenario simple en el que:

  • El bot raíz está diseñado para consumir una aptitud específica.
  • El bot raíz solo tiene una conversación activa con una aptitud a la vez.

El SDK proporciona una clase SkillConversationIdFactory que se puede usar en cualquier aptitud sin necesidad de replicar el código fuente. El generador de identificadores de conversación está configurado en Startup.cs.

Para admitir escenarios más complejos, diseñe un generador de identificadores de conversación que haga lo siguiente:

  • El método crear id. de conversación de aptitudes obtiene o genera el identificador de conversación de aptitudes adecuado.
  • El método obtener referencia de conversación obtiene la conversación de usuario correcta.

Controlador de aptitudes y cliente de aptitudes

El consumidor de aptitudes usa un cliente de aptitudes para reenviar actividades a la aptitud. El cliente utiliza la información de configuración de las aptitudes y el generador de identificaciones de conversación para hacerlo.

El consumidor de aptitudes usa un controlador de aptitudes para recibir actividades de una aptitud. El controlador usa el generador de identificaciones de conversación, la configuración de autenticación y un proveedor de credenciales para hacerlo, y también tiene dependencias en el adaptador del bot raíz y en el controlador de actividades.

SimpleRootBot\Startup.cs

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

El tráfico HTTP de la aptitud entrará en la URL del punto de conexión de servicio en el que el consumidor de aptitudes publica información para la aptitud. Use un controlador de puntos de conexión específico del lenguaje para reenviar el tráfico al controlador de aptitudes.

El controlador de aptitudes predeterminado:

  • Si hay un identificador de aplicación y una contraseña, usa un objeto de configuración de autenticación para realizar la autenticación de bot a bot y la validación de notificaciones.
  • Usa el generador de identificadores de conversación para traducir de la conversación entre el consumidor y la aptitud de nuevo a la conversación entre el bot raíz y el usuario.
  • Genera un mensaje activo para que el consumidor de aptitudes pueda volver a establecer el contexto del turno y las actividades de reenvío de la conversación entre el bot raíz y el usuario.

Lógica del controlador de actividades

Tenga en cuenta que la lógica del consumidor de aptitudes debe:

  • Recordar si hay aptitudes activas y reenviarles las actividades según corresponda.
  • Identificar si un usuario realiza una solicitud que debe reenviarse a una aptitud, e iniciar la aptitud.
  • Buscar una actividad endOfConversation de cualquier aptitud activa, para identificar cuándo se completa.
  • Si es necesario, agregue lógica para que el usuario o el consumidor de aptitudes puedan cancelar una aptitud que aún no ha finalizado.
  • Guarde el estado antes de realizar la llamada a una aptitud, ya que la respuesta podría volver a una instancia diferente del consumidor de aptitudes

SimpleRootBot\Bots\RootBot.cs

El bot raíz tiene dependencias del estado de la conversación, la información de las aptitudes, el cliente de aptitudes y la configuración general. ASP.NET proporciona estos objetos mediante la inserción de dependencias. El bot raíz también define un descriptor de acceso a la propiedad de estado de la conversación para realizar el seguimiento de qué aptitud está activa.

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

En este ejemplo hay un método auxiliar para reenviar actividades a una aptitud. Guarda el estado de la conversación antes de invocar la aptitud y comprueba si la solicitud HTTP se realizó correctamente.

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

Tenga en cuenta que el bot raíz incluye lógica para el reenvío de actividades a la aptitud, el inicio de la aptitud en la solicitud del usuario y la detención de la aptitud cuando esta se completa.

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

Controlador de errores On turn

Cuando se produce un error, el adaptador borra el estado de la conversación para restablecer la conversación con el usuario y evitar que un estado de error persista.

Se recomienda enviar una actividad de final de la conversación las aptitudes activas antes de borrar el estado de la conversación en el consumidor de aptitudes. De este modo, la aptitud libera todos los recursos asociados con la conversación entre el consumidor y la aptitud antes de que el consumidor de aptitudes libere la conversación.

SimpleRootBot\AdapterWithErrorHandler.cs

En este ejemplo, la lógica de errores de turno se divide entre algunos métodos auxiliares.

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

Punto de conexión de aptitudes

El bot define un punto de conexión que reenvía las actividades de aptitudes entrantes al controlador de aptitudes del bot raíz.

SimpleRootBot\Controllers\SkillController.cs

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

Registro de servicios

Incluya un objeto de configuración de autenticación con la validación de notificaciones, además de todos los objetos adicionales. En este ejemplo se usa la misma lógica de configuración de autenticación para validar las actividades de los usuarios y las aptitudes.

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

Prueba del bot raíz

Puede probar el consumidor de aptitudes en el emulador como si fuera un bot normal; sin embargo, tiene que ejecutar los bots de aptitud y del consumidor de aptitudes al mismo tiempo. Vea cómo implementar una aptitud para más información sobre cómo configurar la aptitud.

Descargue e instale la versión más reciente de Bot Framework Emulator.

  1. Ejecute el bot de aptitud de eco y el bot raíz simple en su máquina local. Si necesita instrucciones, consulte el archivo README de C#, JavaScript, Java o Python.
  2. Use el emulador para probar el bot tal y como se muestra a continuación. Cuando se envía un mensaje end o stop a la aptitud, esta envía al bot raíz una actividad endOfConversation, además del mensaje de respuesta. La propiedad code de la actividad endOfConversation indica que la aptitud se completó correctamente.

Transcripción de ejemplo de una interacción con el consumidor de aptitudes.

Más sobre la depuración

Dado que se autentica el tráfico entre aptitudes y consumidores de aptitudes, hay pasos adicionales al depurar estos bots.

  • El consumidor de aptitudes y todas las aptitudes que consume, directa o indirectamente, deben ejecutarse.
  • Si los bots se ejecutan localmente y si alguno de los bots tiene un identificador de aplicación y una contraseña, todos los bots deben tener identificadores y contraseñas válidos.
  • Si todos los bots están implementados, consulte cómo depurar un bot desde cualquier canal mediante devtunnel.
  • Si algunos de los bots se ejecutan localmente y algunos se implementan, consulte cómo depurar una aptitud o consumidor de aptitudes.

De lo contrario, puede depurar un consumidor de aptitudes o una aptitud como depurar otros bots. Para obtener más información, consulte Depuración de un bot y Depuración con Bot Framework Emulator.

Información adicional

Estos son algunos aspectos que se deben tener en cuenta al implementar un bot raíz más complejo.

Para que el usuario pueda cancelar una aptitud de varios pasos

El bot raíz debe comprobar el mensaje del usuario antes de reenviarlo a la aptitud activa. Si el usuario desea cancelar el proceso actual, el bot raíz puede enviar una actividad endOfConversation a la aptitud, en lugar de reenviar el mensaje.

Para intercambiar datos entre el bot raíz y el bot de aptitud

Para enviar parámetros a la aptitud, el consumidor de aptitudes puede establecer la propiedad value en los mensajes que envía a la aptitud. Para recibir los valores devueltos de las aptitudes, el consumidor de aptitudes debe comprobar la propiedad value cuando la aptitud envíe una actividad endOfConversation.

Para usar varias aptitudes

  • Si hay una aptitud activa, el bot raíz debe determinar cuál y reenviar el mensaje del usuario a la aptitud correcta.
  • Si no hay ninguna aptitud activa, el bot raíz debe determinar qué aptitud debe iniciarse, según el estado del bot y los datos de entrada del usuario.
  • Si desea que el usuario pueda cambiar entre varias aptitudes simultáneas, el bot raíz debe determinar con qué aptitudes activas tiene previsto interactuar el usuario antes de reenviar el mensaje del usuario.

Para usar un modo de entrega de respuestas esperadas

Para usar el modo de entrega de respuestas esperadas:

  • Clone la actividad desde el contexto de turno.
  • Establezca la propiedad del modo de entrega de la nueva actividad en "ExpectReplies" antes de enviar la actividad desde el bot raíz a la aptitud.
  • Lea las respuestas esperadas del cuerpo de la respuesta de invocación devuelta de la respuesta de solicitud.
  • Procese cada actividad, ya sea dentro del bot raíz o envíela al canal que inició la solicitud original.

Las respuestas esperadas pueden ser útiles en situaciones en las que el bot que responde a una actividad debe ser la misma instancia del bot que recibió la actividad.