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. Também reúne as capacidades essenciais, incluindo o registo de competências, contas ligadas, intenção conversacional básica para oferecer uma série de interações e experiências totalmente integradas aos utilizadores. 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 criar Assistentes Virtuais e competências. Com o modelo, pode criar um Assistente Virtual, com tecnologia de uma experiência baseada em texto com suporte para cartões avançados limitados com ações. Melhorámos o modelo para incluir as capacidades da plataforma do Microsoft Teams e melhorar as excelentes experiências de aplicações do Teams. Algumas das funcionalidades incluem suporte para cartões ajustáveis avançados, caixas de diálogo (referidos como módulos de tarefas no TeamsJS v1.x), conversas de equipas ou de 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 distribuição não pode ser utilizado para card atividades de ação, uma vez que o modelo luis associado a uma competência é preparado para card textos de ação. 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 competências devem ser incorporadas skillId no value campo das card ações. 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. É apresentado um fragmento de código para extrair skillId de card payload de ação na secção seguinte:

    // 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 fragmento de código para extrair skillId de card dados de ação é apresentado na secção seguinte:

    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 utilizador tenta invocar uma competência enquanto outra competência 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:

Processar pedidos de caixa de diálogo

Para adicionar capacidades de caixa de diálogo a um Assistente Virtual, estão incluídos dois métodos adicionais no processador de atividades do Assistente Virtual: OnTeamsTaskModuleFetchAsync e OnTeamsTaskModuleSubmitAsync. Estes métodos ouvem as atividades relacionadas com a caixa de diálogo do Assistente Virtual, identificam a competência associada ao pedido e reencaminham o pedido para a competência identificada.

O encaminhamento de solicitação é feito por meio do método SkillHttpClient, PostActivityAsync. Devolve 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,
            };
        }

Segue-se uma abordagem semelhante para card respostas de caixa de diálogo e distribuição de ações. Os dados de ação de obtenção e submissão da caixa de diálogo são atualizados para incluir skillId. O método GetSkillId activity Extension extrai skillId do payload, que fornece detalhes sobre a competência que precisa de 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, tem de incluir todos os domínios de competências na validDomains secção no ficheiro de manifesto da aplicação do Assistente Virtual para que as caixas de diálogo invocadas através de uma competência sejam compostas 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. Uma vez que a experiência de inclusão não é adequada para âmbitos de chat de grupo ou canal, esta 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 destes âmbitos não for suportado, as competências têm de responder com uma mensagem adequada.

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

Assim que os comandos forem invocados por um utilizador, o Assistente Virtual pode identificar uma competência associada ao analisar o ID de comando, atualizar a atividade ao remover o sufixo :<skill_id> extra do ID de comando e reencaminhá-lo para a competência 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 mensagens não incluem o ID de comando. Por exemplo, composeExtensions/selectItem contém apenas o valor da ação de toque de invocação. Para identificar a competência associada, skillId é anexado a cada item card enquanto forma uma resposta para OnTeamsMessagingExtensionQueryAsync. Esta abordagem é semelhante à abordagem para adicionar cartões ajustáveis ao 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 seguinte mostra como converter o modelo de aplicação Livro numa sala numa competência de Assistente Virtual: o Livro-uma-sala é um Teams que permite aos utilizadores localizar e reservar rapidamente uma sala de reuniões durante 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:

Seguem-se as alterações delta introduzidas para convertê-la numa competência, que está 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. Este manifesto é diferente do manifesto utilizado para o carregamento de aplicações personalizadas no Teams. Um Assistente Virtual requer um caminho para esse arquivo como uma entrada para anexar uma habilidade. Adicionámos o seguinte manifesto à 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 em .lu formatação com a 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 tem de utilizar o modelo luis para compreender estes comandos se não estiverem escritos na totalidade. 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 o languages parâmetro, atualize o comando de competências do bot da seguinte forma:

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 do Bot Framework tem um campo de região, que é utilizado por este middleware. Você também pode usar o mesmo para sua habilidade. O bot book-a-room não utiliza este middleware e, em vez disso, obtém a região da entidade clientInfo da atividade bot framework.

Validação de declaração

Adicionámos afirmaçõesValidator 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 atualização da atividade, como card atualização ainda não é suportada através do Assistente Virtual (problema do github). Por conseguinte, substituímos todas as chamadas UpdateActivityAsync de atualização card pela publicação de novas chamadas SendActivityAsyncde card .

Ações de cartões e fluxos de caixa de diálogo

Para reencaminhar card ação ou atividades de caixa de diálogo para uma competência associada, a competência tem de ser incorporada skillId na mesma. Book-a-roombot card ação, os payloads de obtenção e submissão da caixa de diálogo são modificados para conter skillId como um parâmetro.

Para obter mais informações, veja Adicionar Cartões Ajustáveis ao 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
        {
            ...
        }
    }

Também pode utilizar competências existentes do repositório bot Framework Solutions ou criar uma nova competência do zero. Para criar uma nova habilidade, consulte tutoriais para criar uma nova habilidade. Para obter a documentação do Assistente Virtual e da arquitetura de competências, veja Assistente Virtual e arquitetura de competências.

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ção termina. Assim, não enviámos endOfConversation a partir do Book-a-room bot e quando o utilizador quer voltar ao contexto de raiz, pode fazê-lo por start over comando.
• Atualização do cartão: a atualização de cartões ainda não é suportada através do Assistente Virtual.
• Extensões de mensagem:
  • Um Assistente Virtual pode suportar um máximo de 10 comandos para extensões de mensagens.
  • A configuração das extensões de mensagens não está confinada a comandos individuais, mas sim a toda a extensão. 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.

Também pode utilizar competências existentes do repositório bot Framework Solutions ou criar uma nova competência do zero. Tutoriais para o posterior podem ser encontrados aqui. Veja a documentação do Assistente Virtual e da arquitetura de competências.

Exemplo de código

Confira também

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