Criar um Assistente Virtual

Assistente Virtual é um modelo de software livre da Microsoft que permite criar uma solução de conversação robusta, mantendo o controle total da experiência do usuário, da identidade visual organizacional e dos dados necessários. O modelo de núcleo do Assistente Virtual é o bloco de construção básico que reúne as tecnologias da Microsoft necessárias para criar um Assistente Virtual, incluindo o SDK do Bot Framework, Reconhecimento vocal (LUIS), e QnA Maker. Ele também reúne os recursos essenciais, incluindo registro de habilidades, contas vinculadas, intenção básica de conversação para oferecer uma variedade de interações e experiências perfeitas aos usuários. Além disso, os recursos de modelo incluem exemplos avançados de habilidades de conversação reutilizáveis. As habilidades individuais são integradas em uma Assistente Virtual para habilitar vários cenários. Usando o SDK do Bot Framework, as habilidades são apresentadas no formulário de código-fonte, permitindo que você personalize e estenda conforme necessário. Para obter mais informações sobre as habilidades do Bot Framework, consulte O que é uma habilidade Bot Framework. Este documento orienta você sobre as Assistente Virtual de implementação para organizações, como criar um Assistente Virtual com foco no Teams, exemplo relacionado, exemplo de código e limitações de Assistente Virtual. A imagem a seguir exibe a visão geral do assistente virtual:

As atividades de mensagem de texto são roteadas para habilidades associadas pelo núcleo do Assistente Virtual usando um modelo de expedição.

Considerações sobre implementação

A decisão de adicionar um Assistente Virtual inclui muitos determinantes e difere para cada organização. Os fatores de suporte de uma Assistente Virtual para sua organização são os seguintes:

• Uma equipe central gerencia todas as experiências dos funcionários. Ele tem a capacidade de criar uma experiência Assistente Virtual e gerenciar atualizações para a experiência principal, incluindo a adição de novas habilidades.
• Existem vários aplicativos entre funções de negócios e o número deve crescer no futuro.
• Os aplicativos existentes são personalizáveis, pertencentes à organização, e são convertidos em habilidades para um Assistente Virtual.
• A equipe central de experiências de funcionários é capaz de influenciar personalizações para aplicativos existentes. Ele também fornece as diretrizes necessárias para integrar aplicativos existentes como habilidades Assistente Virtual experiência.

A imagem a seguir exibe as funções de negócios Assistente Virtual:

Criar um grupo voltado para o Teams Assistente Virtual

A Microsoft publicou um modelo da Microsoft para a criação de Assistentes Virtuais e habilidades. Com o modelo, você pode criar um Assistente Virtual, alimentado por uma experiência baseada em texto com suporte para cartões avançados limitados com ações. Aprimoramos o modelo para incluir os recursos da plataforma Microsoft Teams e potencializar ótimas experiências com os aplicativos Teams. Alguns dos recursos incluem suporte para Cartões Adaptáveis avançados, caixas de diálogo (chamados de módulos de tarefas no TeamsJS v1.x), chats em equipe ou em grupo e extensões de mensagens. Para obter mais informações sobre como estender o Assistente Virtual para o Microsoft Teams, consulte Tutorial: Estenda Seu Assistente Virtual para o Microsoft Teams. A imagem a seguir exibe o diagrama de alto nível de uma Assistente Virtual solução:

Adicione Cartões Adaptáveis ao seu Assistente Virtual

Para expedir solicitações corretamente, Assistente Virtual deve identificar o modelo LUIS correto e a habilidade correspondente associada a ele. No entanto, o mecanismo de expedição não pode ser usado para atividades de ação de card, pois o modelo do LUIS associado a uma habilidade é treinado para textos de ação de card. Os textos de ação do cartão são palavras-chave fixas predefinida e não comentadas de um usuário.

Essa desvantagem é resolvida inserindo informações de habilidade na carga de ação do cartão. Todas as habilidades devem ser incorporadas skillId ao value campo das ações de card. Você deve garantir que cada atividade de ação do cartão transporte as informações de habilidade relevantes e Assistente Virtual pode utilizar essas informações para expedição.

Você deve fornecer skillId no construtor para garantir que as informações de habilidade estejam sempre presentes nas ações do cartão. Um código de exemplo de dados de ação de cartão é mostrado na seção a seguir:

    public class CardActionData
    {
        public CardActionData(string skillId)
        {
            this.SkillId = skillId;
        }

        [JsonProperty("skillId")]
        public string SkillId { get; set; }
    }

    ...
    var button = new CardAction
    {
        Type = ActionTypes.MessageBack,
        Title = "Card action button",
        Text = "card action button text",
        Value = new CardActionData(<SkillId>),
    };

Em seguida, SkillCardActionData no modelo Assistente Virtual é introduzida para extrair skillId da carga de ação do cartão. Um trecho de código para extrair skillId do conteúdo de ação do card é mostrado na seção a seguir:

    // Skill Card action data should contain skillId parameter
    // This class is used to deserialize it and get skillId 
    public class SkillCardActionData
    {
        /// <summary>
        /// Gets the ID of the skil that should handle this card
        /// </summary>
        [JsonProperty("skillId")]
        public string SkillId { get; set; }
    }

A implementação é feita por um método de extensão na classe Atividade. Um trecho de código para extrair skillId dos dados de ação do card é mostrado na seção a seguir:

    public static class ActivityExtensions
    {
        // Fetches skillId from CardAction data if present
        public static string GetSkillId(this Activity activity)
        {
            string skillId = string.Empty;

            try
            {
                if (activity.Type.Equals(ActivityTypes.Message) && activity.Value != null)
                {
                    var data = JsonConvert.DeserializeObject<SkillCardActionData>(activity.Value.ToString());
                    skillId = data.SkillId;
                }
                else if (activity.Type.Equals(ActivityTypes.Invoke) && activity.Value != null)
                {
                    var data = JsonConvert.DeserializeObject<SkillCardActionData>(JObject.Parse(activity.Value.ToString()).SelectToken("data").ToString());
                    skillId = data.SkillId;
                }
            }
            catch
            {
                // If not able to retrieve skillId, empty skillId should be returned
            }

            return skillId;
        }
    }

Lidar com interrupções

O Assistente Virtual pode lidar com interrupções nos casos em que um usuário tenta invocar uma habilidade enquanto outra habilidade está ativa. TeamsSkillDialog e TeamsSwitchSkillDialog são introduzidos com base no SkillDialog e SwitchSkillDialog do Bot Framework. Eles permitem que os usuários alternem uma experiência de habilidade de ações de cartão. Para lidar com essa solicitação, o Assistente Virtual solicita ao usuário uma mensagem de confirmação para alternar as habilidades:

Lidar com solicitações de diálogo

Para adicionar recursos de caixa de diálogo a um Assistente Virtual, dois métodos adicionais são incluídos no manipulador de atividades do Assistente Virtual: OnTeamsTaskModuleFetchAsync e OnTeamsTaskModuleSubmitAsync. Esses métodos ouvem atividades relacionadas ao diálogo do Assistente Virtual, identificam a habilidade associada à solicitação e encaminham a solicitação para a habilidade identificada.

O encaminhamento de solicitação é feito por meio do método SkillHttpClient, PostActivityAsync. Ele retorna a resposta como InvokeResponse, que é analisada e convertida em TaskModuleResponse .

    public static TaskModuleResponse GetTaskModuleRespose(this InvokeResponse invokeResponse)
    {
        if (invokeResponse.Body != null)
        {
            return new TaskModuleResponse()
            {
                Task = GetTask(invokeResponse.Body),
            };
        }

        return null;
    }

    private static TaskModuleResponseBase GetTask(object invokeResponseBody)
        {
            JObject resposeBody = (JObject)JToken.FromObject(invokeResponseBody);
            var task = resposeBody.GetValue("task");
            var taskType = task.SelectToken("type").ToString();

            return taskType switch
            {
                "continue" => new TaskModuleContinueResponse()
                {
                    Type = taskType,
                    Value = task.SelectToken("value").ToObject<TaskModuleTaskInfo>(),
                },
                "message" => new TaskModuleMessageResponse()
                {
                    Type = taskType,
                    Value = task.SelectToken("value").ToString(),
                },
                _ => null,
            };
        }

Uma abordagem semelhante é seguida para despacho de ação de card e respostas de diálogo. A caixa de diálogo buscar e enviar dados de ação foi atualizada para incluir skillId. O método GetSkillId Activity Extension extrai da skillId carga, que fornece detalhes sobre a habilidade que precisa ser invocada.

O trecho de código para métodos OnTeamsTaskModuleFetchAsync e OnTeamsTaskModuleSubmitAsync são fornecidos na seção a seguir:

    // Invoked when a "task/fetch" event is received to invoke dialog.
    protected override async Task<TaskModuleResponse> OnTeamsTaskModuleFetchAsync(ITurnContext<IInvokeActivity> turnContext, TaskModuleRequest taskModuleRequest, CancellationToken cancellationToken)
    {
        try
        {
            string skillId = (turnContext.Activity as Activity).GetSkillId();
            var skill = _skillsConfig.Skills.Where(s => s.Value.AppId == skillId).First().Value;

            // Forward request to correct skill
            var invokeResponse = await _skillHttpClient.PostActivityAsync(this._appId, skill, _skillsConfig.SkillHostEndpoint, turnContext.Activity as Activity, cancellationToken);

            return invokeResponse.GetTaskModuleResponse();
        }
        catch (Exception exception)
        {
            await turnContext.SendActivityAsync(_templateEngine.GenerateActivityForLocale("ErrorMessage"));
            _telemetryClient.TrackException(exception);

            return null;
        }
    }

    // Invoked when a 'task/submit' invoke activity is received for dialog submit actions.
    protected override async Task<TaskModuleResponse> OnTeamsTaskModuleSubmitAsync(ITurnContext<IInvokeActivity> turnContext, TaskModuleRequest taskModuleRequest, CancellationToken cancellationToken)
    {
        try
        {
            string skillId = (turnContext.Activity as Activity).GetSkillId();
            var skill = _skillsConfig.Skills.Where(s => s.Value.AppId == skillId).First().Value;

            // Forward request to correct skill
            var invokeResponse = await _skillHttpClient.PostActivityAsync(this._appId, skill, _skillsConfig.SkillHostEndpoint, turnContext.Activity as Activity, cancellationToken).ConfigureAwait(false);

            return invokeResponse.GetTaskModuleRespose();
        }
        catch (Exception exception)
        {
            await turnContext.SendActivityAsync(_templateEngine.GenerateActivityForLocale("ErrorMessage"));
            _telemetryClient.TrackException(exception);

            return null;
        }
    }

Além disso, você deve incluir todos os domínios de habilidade na seção no arquivo de manifestovalidDomains do aplicativo do Assistente Virtual para que as caixas de diálogo invocadas por meio de uma habilidade sejam processadas corretamente.

Manipular escopos de aplicativo colaborativos

Os aplicativos do Teams podem existir em vários escopos, incluindo chat 1:1, chat em grupo e canais. O modelo do núcleo do Assistente Virtual foi projetado para chats individuais. Como parte da experiência de integração, Assistente Virtual solicita aos usuários o nome e mantém o estado do usuário. Como a experiência de integração não é adequada para chat em grupo ou escopos de canal, ela foi removida.

As habilidades devem lidar com atividades em vários escopos, como chat 1:1, chat em grupo e conversa de canal. Se algum desses escopos não tiver suporte, as habilidades deverão responder com uma mensagem apropriada.

As seguintes funções de processamento foram adicionadas ao núcleo do Assistente Virtual:

• Assistente Virtual pode ser invocado sem qualquer mensagem de texto de um chat em grupo ou canal.
• Os erros são limpos antes de enviar a mensagem para o módulo de expedição. Por exemplo, remova o necessário @mention do bot.

    if (innerDc.Context.Activity.Conversation?.IsGroup == true)
    {
        // Remove bot atmentions for teams/groupchat scope
        innerDc.Context.Activity.RemoveRecipientMention();

        // If bot is invoked without any text, reply with FirstPromptMessage
        if (string.IsNullOrWhiteSpace(innerDc.Context.Activity.Text))
        {
            await innerDc.Context.SendActivityAsync(_templateEngine.GenerateActivityForLocale("FirstPromptMessage"));
            return EndOfTurn;
        }
    }

Manipular extensões de mensagem

Os comandos para uma extensão de mensagem são declarados no arquivo de manifesto do aplicativo. A interface do usuário da extensão de mensagem é ativada por esses comandos. Para que Assistente Virtual um comando de extensão de mensagem como uma habilidade anexada, Assistente Virtual manifesto de uma Assistente Virtual deve conter esses comandos. Você deve adicionar os comandos do manifesto de uma habilidade individual ao Assistente Virtual manifesto do usuário. A ID do comando fornece informações sobre uma habilidade associada acrescentando a ID do aplicativo da habilidade por meio de um separador :.

O trecho do arquivo de manifesto de uma habilidade é mostrado na seção a seguir:

 "composeExtensions": [
    {
        "botId": "<Skil_App_Id>",
        "commands": [
            {
                "id": "searchQuery",
                "context": [ "compose", "commandBox" ],
                "description": "Test command to run query",
                 ....}
         ]
     }
 ]
                 

O trecho de código do arquivo de manifesto correspondente do Assistente Virtual é mostrado na seção a seguir:

 "composeExtensions": [
    {
        "botId": "<VA_App_Id>",
        "commands": [
            {
                "id": "searchQuery:<skill_id>",
                "context": [ "compose", "commandBox" ],
                "description": "Test command to run query",
                 ....}
         ]
     }
 ]
 

Depois que os comandos são invocados por um usuário, o Assistente Virtual pode identificar uma habilidade associada analisando a ID do comando, atualizar a atividade removendo o sufixo :<skill_id> extra da ID do comando e encaminhá-la para a habilidade correspondente. O código de uma habilidade não precisa lidar com o sufixo extra. Portanto, conflitos entre IDs de comando entre habilidades são evitados. Com essa abordagem, todos os comandos de pesquisa e ação de uma habilidade em todos os contextos, como compose, commandBox e message são alimentados por um Assistente Virtual.

    const string MessagingExtensionCommandIdSeparator = ":";

    // Invoked when a 'composeExtension/submitAction' invoke activity is received for a messaging extension action command
    protected override async Task<MessagingExtensionActionResponse> OnTeamsMessagingExtensionSubmitActionAsync(ITurnContext<IInvokeActivity> turnContext, MessagingExtensionAction action, CancellationToken cancellationToken)
    {
        return await ForwardMessagingExtensionActionCommandActivityToSkill(turnContext, action, cancellationToken);
    }

    // Forwards invoke activity to right skill for messaging extension action commands.
    private async Task<MessagingExtensionActionResponse> ForwardMessagingExtensionActionCommandActivityToSkill(ITurnContext<IInvokeActivity> turnContext, MessagingExtensionAction action, CancellationToken cancellationToken)
    {
        var skillId = ExtractSkillIdFromMessagingExtensionActionCommand(turnContext, action);
        var skill = _skillsConfig.Skills.Where(s => s.Value.AppId == skillId).First().Value;
        var invokeResponse = await _skillHttpClient.PostActivityAsync(this._appId, skill, _skillsConfig.SkillHostEndpoint, turnContext.Activity as Activity, cancellationToken).ConfigureAwait(false);

        return invokeResponse.GetMessagingExtensionActionResponse();
    }

    // Extracts skill Id from messaging extension command and updates activity value
    private string ExtractSkillIdFromMessagingExtensionActionCommand(ITurnContext<IInvokeActivity> turnContext, MessagingExtensionAction action)
    {
        var commandArray = action.CommandId.Split(MessagingExtensionCommandIdSeparator);
        var skillId = commandArray.Last();

        // Update activity value by removing skill id before forwarding to the skill.
        var activityValue = JsonConvert.DeserializeObject<MessagingExtensionAction>(turnContext.Activity.Value.ToString());
        activityValue.CommandId = string.Join(MessagingExtensionCommandIdSeparator, commandArray, 0 commandArray.Length - 1);
        turnContext.Activity.Value = activityValue;

        return skillId;
    }

Algumas atividades de extensão de mensagem não incluem a ID de comando. Por exemplo, composeExtensions/selectItem contém apenas o valor da ação de toque de invocação. Para identificar a habilidade associada, skillId é anexado a cada item card enquanto forma uma resposta para OnTeamsMessagingExtensionQueryAsync. Isso é semelhante à abordagem para adicionar cartões adaptáveis ao seu Assistente Virtual.

    // Invoked when a 'composeExtension/selectItem' invoke activity is received for compose extension query command.
    protected override async Task<MessagingExtensionResponse> OnTeamsMessagingExtensionSelectItemAsync(ITurnContext<IInvokeActivity> turnContext, JObject query, CancellationToken cancellationToken)
    {
        var data = JsonConvert.DeserializeObject<SkillCardActionData>(query.ToString());
        var skill = _skillsConfig.Skills.Where(s => s.Value.AppId == data.SkillId).First().Value;
        var invokeResponse = await _skillHttpClient.PostActivityAsync(this._appId, skill, _skillsConfig.SkillHostEndpoint, turnContext.Activity as Activity, cancellationToken).ConfigureAwait(false);

        return invokeResponse.GetMessagingExtensionResponse();
    }

Exemplo

O exemplo a seguir mostra como converter o modelo de aplicativo Reserve uma sala em uma habilidade de Assistente Virtual: Book-a-room é um Teams que permite aos usuários encontrar e reservar rapidamente uma sala de reunião por 30, 60 ou 90 minutos a partir da hora atual. O tempo padrão é de 30 minutos. O bot agendar uma sala tem escopos para conversas pessoais ou 1:1. A imagem a seguir exibe um Assistente Virtual com uma habilidade agendar uma sala:

A seguir estão as alterações delta introduzidas para convertê-lo em uma habilidade, que é anexada a um Assistente Virtual. Diretrizes semelhantes são seguidas para converter qualquer bot v4 existente em uma habilidade.

Manifesto de habilidade

Um manifesto de habilidade é um arquivo JSON que expõe o ponto de extremidade de mensagens, a ID, o nome e outros metadados relevantes de uma habilidade. Esse manifesto é diferente do manifesto usado para upload de aplicativo personalizado no Teams. Um Assistente Virtual requer um caminho para esse arquivo como uma entrada para anexar uma habilidade. Adicionamos o manifesto a seguir à pasta wwwroot do bot.

botskills connect --remoteManifest "<url to skill's manifest>" ..

{
  "$schema": "https://schemas.botframework.com/schemas/skills/skill-manifest-2.1.preview-0.json",
  "$id": "microsoft_teams_apps_bookaroom",
  "name": "microsoft-teams-apps-bookaroom",
  "description": "microsoft-teams-apps-bookaroom description",
  "publisherName": "Your Company",
  "version": "1.1",
  "iconUrl": "<icon url>",
  "copyright": "Copyright (c) Microsoft Corporation. All rights reserved.",
  "license": "",
  "privacyUrl": "<privacy url>",
  "endpoints": [
    {
      "name": "production",
      "protocol": "BotFrameworkV3",
      "description": "Production endpoint for the skill",
      "endpointUrl": "<endpoint url>",
      "msAppId": "skill app id"
    }
  ],
  "dispatchModels": {
    "languages": {
      "en-us": [
        {
          "id": "microsoft-teams-apps-bookaroom-en",
          "name": "microsoft-teams-apps-bookaroom LU (English)",
          "contentType": "application/lu",
          "url": "file://book-a-meeting.lu",
          "description": "English language model for the skill"
        }
      ]
    }
  },
  "activities": {
    "message": {
      "type": "message",
      "description": "Receives the users utterance and attempts to resolve it using the skill's LU models"
    }
  }
}

Integração do LUIS

Assistente Virtual modelo de expedição da Assistente Virtual é criado com base nos modelos LUIS das habilidades anexadas. O modelo de expedição identifica a intenção de cada atividade de texto e descobre a habilidade associada a ela.

Assistente Virtual requer o modelo LUIS da habilidade no formato .lu como uma entrada ao anexar uma habilidade. O JSON do LUIS é convertido para formato usando a .lu ferramenta botframework-cli.

botskills connect --remoteManifest "<url to skill's manifest>" --luisFolder "<path to the folder containing your Skill's .lu files>" --languages "en-us" --cs

npm i -g @microsoft/botframework-cli
bf luis:convert --in <pathToLUIS.json> --out <pathToLuFile>

O bot agendar uma sala tem dois comandos principais para os usuários:

• Book room
• Manage Favorites

Criamos um modelo LUIS compreendendo esses dois comandos. Os segredos correspondentes devem ser preenchidos em cognitivemodels.json. O arquivo JSON do LUIS correspondente é encontrado aqui. O arquivo .lu correspondente é mostrado na seção a seguir:

> ! Automatically generated by [LUDown CLI](https://github.com/Microsoft/botbuilder-tools/tree/master/Ludown), Tue Mar 31 2020 17:30:32 GMT+0530 (India Standard Time)

> ! Source LUIS JSON file: book-a-meeting.json

> ! Source QnA TSV file: Not Specified

> ! Source QnA Alterations file: Not Specified


> # Intent definitions

## BOOK ROOM
- book a room
- book room
- please book a room
- reserve a room
- i want to book a room
- i want to book a room please
- get me a room please
- get me a room


## MANAGE FAVORITES
- manage favorites
- manage favorite
- please manage my favorite rooms
- manage my favorite rooms please
- manage my favorite rooms
- i want to manage my favorite rooms

## None


> # Entity definitions


> # PREBUILT Entity definitions


> # Phrase list definitions


> # List entities

> # RegEx entities

Com essa abordagem, qualquer comando emitido por um usuário para Assistente Virtual relacionado a book room ou manage favorites são identificados como um comando associado ao bot Book-a-room e são encaminhados para essa habilidade. Por outro lado, Book-a-room room o bot precisará usar o modelo LUIS para entender esses comandos se eles não forem digitados completos. Por exemplo: I want to manage my favorite rooms.

Suporte a vários idiomas

Por exemplo, um modelo LUIS com apenas cultura em inglês é criado. Você pode criar modelos LUIS correspondentes a outros idiomas e adicionar entrada a cognitivemodels.json.

{
  "defaultLocale": "en-us",
  "languageModels": {
    "en-us": {
      "luisAppId": "",
      "luisApiKey": "",
      "luisApiHost": ""
    },
    "<your_language_culture>": {
      "luisAppId": "",
      "luisApiKey": "",
      "luisApiHost": ""
    }
  }
}

Em paralelo, adicione o arquivo .lu no caminho luisFolder. A estrutura de pastas deve ser a seguinte:

| - luisFolder

        | - en-us

                | - book-a-meeting.lu

        | - your_language_culture

                | - book-a-meeting.lu

Para modificar languages o parâmetro, atualize o comando bot skills da seguinte maneira:

botskills connect --remoteManifest "<url to skill's manifest>" --luisFolder "<path to luisFolder>" --languages "en-us, your_language_culture" --cs

Assistente Virtual usa SetLocaleMiddleware para identificar a localidade atual e invocar o modelo de expedição correspondente. A atividade da estrutura de bot tem o campo locale, que é usado por este middleware. Você também pode usar o mesmo para sua habilidade. O bot Book-a-room não usa esse middleware e, em vez disso, obtém a localidade da entidade clientInfo da atividade da estrutura do Bot.

Validação de declaração

Adicionamos claimsValidator para restringir os chamadores à habilidade. Para permitir que um Assistente Virtual chame essa habilidade, preencha a matriz AllowedCallers de appsettings com a ID do aplicativo Assistente Virtual específica.

"AllowedCallers": [ "<caller_VA1_appId>", "<caller_VA2_appId>" ],

A matriz de chamadores permitidos pode restringir quais consumidores de habilidades podem acessar a habilidade. Adicione uma única entrada * a essa matriz para aceitar chamadas de qualquer consumidor de habilidades.

"AllowedCallers": [ "*" ],

Para obter mais informações sobre como adicionar validação de declarações a uma habilidade, consulte adicionar validação de declarações à habilidade.

Limitação da atualização do cartão

A atividade de atualização, como a atualização do card, ainda não é compatível por meio do Assistente Virtual (problema do github). Portanto, substituímos todas as chamadas UpdateActivityAsync de atualização de card pela postagem de novas chamadas SendActivityAsyncde card.

Ações de cartão e fluxos de diálogo

Para encaminhar atividades de ação ou diálogo de card para uma habilidade associada, a habilidade deve ser incorporada skillId a ela. Book-a-roomBot card action, dialog fetch e submit action payloads são modificados para conter skillId como um parâmetro.

Para obter mais informações, consulte Adicionar Cartões Adaptáveis ao seu Assistente Virtual.

Manipular atividades do chat em grupo ou do escopo do canal

Book-a-room bot foi projetado para chats privados, como apenas escopo pessoal ou 1:1. Como personalizamos o Assistente Virtual para dar suporte aos escopos de canal e chat em grupo, o Assistente Virtual deve ser invocado dos escopos do canal e, portanto, o bot Book-a-room deve obter atividades para o mesmo escopo. PortantoBook-a-roombot é personalizado para lidar com essas atividades. Você pode encontrar a verificação nos métodos OnMessageActivityAsync do manipulador de atividade do bot Book-a-room.

    protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
    {
        // Check if activities are from groupchat/ teams scope. This might happen when the bot is consumed by Virtual Assistant.
        if (turnContext.Activity.Conversation.IsGroup == true)
        {
            await ShowNotSupportedInGroupChatCardAsync(turnContext).ConfigureAwait(false);
        }
        else
        {
            ...
        }
    }

Você também pode usar as habilidades existentes do repositório de Soluções do Bot Framework ou criar uma nova habilidade do zero. Para criar uma nova habilidade, consulte tutoriais para criar uma nova habilidade. Para o Assistente Virtual e a documentação de arquitetura de habilidades, consulte Assistente Virtual e arquitetura de habilidades.

Limitações de Assistente Virtual

• EndOfConversation: Uma habilidade deve enviar uma atividade endOfConversation quando terminar uma conversa. Com base na atividade, um Assistente Virtual termina o contexto com essa habilidade específica e volta Assistente Virtual contexto raiz do usuário. Para o bot Book-a-room, não há um estado claro onde a conversa é encerrada. Portanto, não enviamos endOfConversation do Book-a-room bot e, quando o usuário deseja voltar ao contexto raiz, ele pode fazer isso por start over comando.
• Atualização de cartão: a atualização de cartão ainda não é compatível por meio do Assistente Virtual.
• Extensões de mensagem:
  • Um Assistente Virtual pode dar suporte a no máximo 10 comandos para extensões de mensagem.
  • A configuração das extensões de mensagem não tem como escopo comandos individuais, mas para toda a extensão em si. Isso limita a configuração de cada habilidade individual por meio Assistente Virtual.
  • As IDs de comando de extensões de mensagem têm um comprimento máximo de 64 caracteres e 37 caracteres são usados para inserir informações de habilidade. Assim, as restrições atualizadas para a ID de comando são limitadas a 27 caracteres.

Você também pode usar as habilidades existentes do repositório de Soluções do Bot Framework ou criar uma nova habilidade do zero. Tutoriais para o posterior podem ser encontrados aqui. Consulte a documentação do Assistente Virtual e da arquitetura de habilidades.

Exemplo de código

Confira também

• Integrar aplicativos Web
• Cartões Adaptáveis
• Agendar uma sala
• Bot do Microsoft Teams