​

Microsoft Teams

“Abandonai toda esperança, vós que aqui entrais.”

​

Plugin incluído

openclaw plugins install @openclaw/msteams

openclaw plugins install ./path/to/local/msteams-plugin

​

Configuração rápida (iniciante)

1. Verifique se o plugin do Microsoft Teams está disponível.
   • As versões empacotadas atuais do OpenClaw já o incluem.
   • Instalações antigas/personalizadas podem adicioná-lo manualmente com os comandos acima.
2. Crie um Azure Bot (App ID + segredo do cliente + ID do locatário).
3. Configure o OpenClaw com essas credenciais.
4. Exponha /api/messages (porta 3978 por padrão) por meio de uma URL pública ou túnel.
5. Instale o pacote do aplicativo Teams e inicie o gateway.

{
  channels: {
    msteams: {
      enabled: true,
      appId: "<APP_ID>",
      appPassword: "<APP_PASSWORD>",
      tenantId: "<TENANT_ID>",
      webhook: { port: 3978, path: "/api/messages" },
    },
  },
}

​

Objetivos

• Conversar com o OpenClaw por DMs, chats em grupo ou canais do Teams.
• Manter o roteamento determinístico: as respostas sempre voltam para o canal em que chegaram.
• Adotar por padrão um comportamento seguro no canal (menções obrigatórias, salvo configuração em contrário).

​

Escritas de configuração

{
  channels: { msteams: { configWrites: false } },
}

​

Controle de acesso (DMs + grupos)

• Padrão: channels.msteams.dmPolicy = "pairing". Remetentes desconhecidos são ignorados até serem aprovados.
• channels.msteams.allowFrom deve usar IDs de objeto AAD estáveis.
• UPNs/nomes de exibição são mutáveis; a correspondência direta fica desativada por padrão e só é ativada com channels.msteams.dangerouslyAllowNameMatching: true.
• O assistente pode resolver nomes para IDs por meio do Microsoft Graph quando as credenciais permitirem.

• Padrão: channels.msteams.groupPolicy = "allowlist" (bloqueado, a menos que você adicione groupAllowFrom). Use channels.defaults.groupPolicy para substituir o padrão quando não definido.
• channels.msteams.groupAllowFrom controla quais remetentes podem acionar em chats/canais de grupo (usa channels.msteams.allowFrom como fallback).
• Defina groupPolicy: "open" para permitir qualquer membro (ainda condicionado a menção por padrão).
• Para não permitir nenhum canal, defina channels.msteams.groupPolicy: "disabled".

{
  channels: {
    msteams: {
      groupPolicy: "allowlist",
      groupAllowFrom: ["user@org.com"],
    },
  },
}

• Delimite respostas em grupos/canais listando equipes e canais em channels.msteams.teams.
• As chaves devem usar IDs estáveis de equipe e IDs de conversa de canal.
• Quando groupPolicy="allowlist" e houver uma lista de permissões de equipes, somente as equipes/canais listados serão aceitos (condicionados a menção).
• O assistente de configuração aceita entradas Team/Channel e as armazena para você.
• Na inicialização, o OpenClaw resolve nomes de equipe/canal e nomes de usuários da lista de permissões para IDs (quando as permissões do Graph permitem) e registra o mapeamento em log; nomes de equipe/canal não resolvidos são mantidos como digitados, mas ignorados para roteamento por padrão, a menos que channels.msteams.dangerouslyAllowNameMatching: true esteja ativado.

{
  channels: {
    msteams: {
      groupPolicy: "allowlist",
      teams: {
        "My Team": {
          channels: {
            General: { requireMention: true },
          },
        },
      },
    },
  },
}

​

Como funciona

1. Verifique se o plugin do Microsoft Teams está disponível.
   • As versões empacotadas atuais do OpenClaw já o incluem.
   • Instalações antigas/personalizadas podem adicioná-lo manualmente com os comandos acima.
2. Crie um Azure Bot (App ID + segredo + ID do locatário).
3. Crie um pacote de aplicativo Teams que faça referência ao bot e inclua as permissões RSC abaixo.
4. Envie/instale o aplicativo Teams em uma equipe (ou no escopo pessoal para DMs).
5. Configure msteams em ~/.openclaw/openclaw.json (ou variáveis de ambiente) e inicie o gateway.
6. O gateway escuta o tráfego de webhook do Bot Framework em /api/messages por padrão.

​

Configuração do Azure Bot (Pré-requisitos)

​

Etapa 1: Criar Azure Bot

1. Acesse Create Azure Bot
2. Preencha a guia Basics:

   Campo	Valor
   Bot handle	O nome do seu bot, por exemplo, openclaw-msteams (deve ser único)
   Subscription	Selecione sua assinatura do Azure
   Resource group	Crie um novo ou use um existente
   Pricing tier	Free para desenvolvimento/testes
   Type of App	Single Tenant (recomendado - consulte a observação abaixo)
   Creation type	Create new Microsoft App ID

Aviso de descontinuação: a criação de novos bots multilocatário foi descontinuada após 2025-07-31. Use Single Tenant para novos bots.

3. Clique em Review + create → Create (aguarde ~1-2 minutos)

​

Etapa 2: Obter credenciais

1. Acesse seu recurso Azure Bot → Configuration
2. Copie Microsoft App ID → este é o seu appId
3. Clique em Manage Password → vá para o Registro de Aplicativo
4. Em Certificates & secrets → New client secret → copie o Value → este é o seu appPassword
5. Acesse Overview → copie Directory (tenant) ID → este é o seu tenantId

​

Etapa 3: Configurar endpoint de mensagens

1. Em Azure Bot → Configuration
2. Defina Messaging endpoint como a URL do seu webhook:
   • Produção: https://your-domain.com/api/messages
   • Desenvolvimento local: use um túnel (consulte Desenvolvimento local abaixo)

​

Etapa 4: Ativar canal Teams

1. Em Azure Bot → Channels
2. Clique em Microsoft Teams → Configure → Save
3. Aceite os Termos de Serviço

​

Autenticação federada (Certificado + Identidade Gerenciada)

Adicionado em 2026.3.24

​

Opção A: Autenticação baseada em certificado

1. Gere ou obtenha um certificado (formato PEM com chave privada).
2. Em Entra ID → App Registration → Certificates & secrets → Certificates → envie o certificado público.

{
  channels: {
    msteams: {
      enabled: true,
      appId: "<APP_ID>",
      tenantId: "<TENANT_ID>",
      authType: "federated",
      certificatePath: "/path/to/cert.pem",
      webhook: { port: 3978, path: "/api/messages" },
    },
  },
}

• MSTEAMS_AUTH_TYPE=federated
• MSTEAMS_CERTIFICATE_PATH=/path/to/cert.pem

​

Opção B: Identidade Gerenciada do Azure

1. O pod/VM do bot tem uma identidade gerenciada (atribuída pelo sistema ou pelo usuário).
2. Uma credencial de identidade federada vincula a identidade gerenciada ao registro do aplicativo Entra ID.
3. Em tempo de execução, o OpenClaw usa @azure/identity para adquirir tokens do endpoint Azure IMDS (169.254.169.254).
4. O token é passado ao SDK do Teams para autenticação do bot.

• Infraestrutura do Azure com identidade gerenciada ativada (identidade de workload do AKS, App Service, VM)
• Credencial de identidade federada criada no registro do aplicativo Entra ID
• Acesso de rede ao IMDS (169.254.169.254:80) a partir do pod/VM

{
  channels: {
    msteams: {
      enabled: true,
      appId: "<APP_ID>",
      tenantId: "<TENANT_ID>",
      authType: "federated",
      useManagedIdentity: true,
      webhook: { port: 3978, path: "/api/messages" },
    },
  },
}

{
  channels: {
    msteams: {
      enabled: true,
      appId: "<APP_ID>",
      tenantId: "<TENANT_ID>",
      authType: "federated",
      useManagedIdentity: true,
      managedIdentityClientId: "<MI_CLIENT_ID>",
      webhook: { port: 3978, path: "/api/messages" },
    },
  },
}

• MSTEAMS_AUTH_TYPE=federated
• MSTEAMS_USE_MANAGED_IDENTITY=true
• MSTEAMS_MANAGED_IDENTITY_CLIENT_ID=<client-id> (somente para atribuição pelo usuário)

​

Configuração da identidade de workload do AKS

1. Ative a identidade de workload no cluster do AKS.
2. Crie uma credencial de identidade federada no registro do aplicativo Entra ID:
   az ad app federated-credential create --id <APP_OBJECT_ID> --parameters '{
     "name": "my-bot-workload-identity",
     "issuer": "<AKS_OIDC_ISSUER_URL>",
     "subject": "system:serviceaccount:<NAMESPACE>:<SERVICE_ACCOUNT>",
     "audiences": ["api://AzureADTokenExchange"]
   }'
   
3. Anote a conta de serviço do Kubernetes com o ID do cliente do aplicativo:
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: my-bot-sa
     annotations:
       azure.workload.identity/client-id: "<APP_CLIENT_ID>"
   
4. Rotule o pod para injeção da identidade de workload:
   metadata:
     labels:
       azure.workload.identity/use: "true"
   
5. Garanta o acesso de rede ao IMDS (169.254.169.254) — se estiver usando NetworkPolicy, adicione uma regra de saída permitindo tráfego para 169.254.169.254/32 na porta 80.

​

Comparação dos tipos de autenticação

​

Desenvolvimento local (Tunelamento)

ngrok http 3978
# Copie a URL https, por exemplo, https://abc123.ngrok.io
# Defina o endpoint de mensagens como: https://abc123.ngrok.io/api/messages

tailscale funnel 3978
# Use sua URL do Tailscale funnel como endpoint de mensagens

​

Portal do Desenvolvedor do Teams (Alternativa)

1. Clique em + New app
2. Preencha as informações básicas (nome, descrição, informações do desenvolvedor)
3. Vá para App features → Bot
4. Selecione Enter a bot ID manually e cole o App ID do seu Azure Bot
5. Marque os escopos: Personal, Team, Group Chat
6. Clique em Distribute → Download app package
7. No Teams: Apps → Manage your apps → Upload a custom app → selecione o ZIP

​

Testando o bot

1. No Portal do Azure → seu recurso Azure Bot → Test in Web Chat
2. Envie uma mensagem — você deverá ver uma resposta
3. Isso confirma que seu endpoint de webhook funciona antes da configuração do Teams

1. Instale o aplicativo do Teams (sideload ou catálogo da organização)
2. Encontre o bot no Teams e envie uma DM
3. Verifique os logs do gateway para atividade recebida

​

Configuração (mínima, somente texto)

1. Verifique se o plugin do Microsoft Teams está disponível
   • As versões empacotadas atuais do OpenClaw já o incluem.
   • Instalações antigas/personalizadas podem adicioná-lo manualmente:
     • Do npm: openclaw plugins install @openclaw/msteams
     • De um checkout local: openclaw plugins install ./path/to/local/msteams-plugin
2. Registro do bot
   • Crie um Azure Bot (consulte acima) e anote:
     • App ID
     • Segredo do cliente (senha do aplicativo)
     • ID do locatário (locatário único)
3. Manifesto do aplicativo Teams
   • Inclua uma entrada bot com botId = <App ID>.
   • Escopos: personal, team, groupChat.
   • supportsFiles: true (obrigatório para manipulação de arquivos no escopo pessoal).
   • Adicione permissões RSC (abaixo).
   • Crie ícones: outline.png (32x32) e color.png (192x192).
   • Compacte os três arquivos juntos: manifest.json, outline.png, color.png.
4. Configure o OpenClaw
   {
     channels: {
       msteams: {
         enabled: true,
         appId: "<APP_ID>",
         appPassword: "<APP_PASSWORD>",
         tenantId: "<TENANT_ID>",
         webhook: { port: 3978, path: "/api/messages" },
       },
     },
   }
   
   Você também pode usar variáveis de ambiente em vez de chaves de configuração:
   • MSTEAMS_APP_ID
   • MSTEAMS_APP_PASSWORD
   • MSTEAMS_TENANT_ID
   • MSTEAMS_AUTH_TYPE (opcional: "secret" ou "federated")
   • MSTEAMS_CERTIFICATE_PATH (federada + certificado)
   • MSTEAMS_CERTIFICATE_THUMBPRINT (opcional, não obrigatório para autenticação)
   • MSTEAMS_USE_MANAGED_IDENTITY (federada + identidade gerenciada)
   • MSTEAMS_MANAGED_IDENTITY_CLIENT_ID (somente MI atribuída pelo usuário)
5. Endpoint do bot
   • Defina o endpoint de mensagens do Azure Bot como:
     • https://<host>:3978/api/messages (ou o caminho/porta que você escolher).
6. Execute o gateway
   • O canal Teams inicia automaticamente quando o plugin incluído ou instalado manualmente está disponível e existe configuração msteams com credenciais.

​

Ação de informações do membro

• Permissão RSC Member.Read.Group (já incluída no manifesto recomendado)
• Para consultas entre equipes: permissão de Aplicativo do Graph User.Read.All com consentimento de administrador

​

Contexto do histórico

• channels.msteams.historyLimit controla quantas mensagens recentes de canal/grupo são incluídas no prompt.
• Usa messages.groupChat.historyLimit como fallback. Defina 0 para desativar (padrão: 50).
• O histórico de thread obtido é filtrado pelas listas de permissões de remetentes (allowFrom / groupAllowFrom), portanto a semeadura de contexto da thread inclui apenas mensagens de remetentes permitidos.
• O contexto de anexo citado (ReplyTo* derivado do HTML de resposta do Teams) atualmente é repassado como recebido.
• Em outras palavras, as listas de permissões controlam quem pode acionar o agente; hoje, apenas caminhos específicos de contexto suplementar são filtrados.
• O histórico de DM pode ser limitado com channels.msteams.dmHistoryLimit (turnos do usuário). Substituições por usuário: channels.msteams.dms["<user_id>"].historyLimit.

​

Permissões RSC atuais do Teams (Manifesto)

• ChannelMessage.Read.Group (Application) - receber todas as mensagens do canal sem @menção
• ChannelMessage.Send.Group (Application)
• Member.Read.Group (Application)
• Owner.Read.Group (Application)
• ChannelSettings.Read.Group (Application)
• TeamMember.Read.Group (Application)
• TeamSettings.Read.Group (Application)

• ChatMessage.Read.Chat (Application) - receber todas as mensagens de chat em grupo sem @menção

​

Exemplo de manifesto do Teams (redigido)

{
  $schema: "https://developer.microsoft.com/en-us/json-schemas/teams/v1.23/MicrosoftTeams.schema.json",
  manifestVersion: "1.23",
  version: "1.0.0",
  id: "00000000-0000-0000-0000-000000000000",
  name: { short: "OpenClaw" },
  developer: {
    name: "Your Org",
    websiteUrl: "https://example.com",
    privacyUrl: "https://example.com/privacy",
    termsOfUseUrl: "https://example.com/terms",
  },
  description: { short: "OpenClaw in Teams", full: "OpenClaw in Teams" },
  icons: { outline: "outline.png", color: "color.png" },
  accentColor: "#5B6DEF",
  bots: [
    {
      botId: "11111111-1111-1111-1111-111111111111",
      scopes: ["personal", "team", "groupChat"],
      isNotificationOnly: false,
      supportsCalling: false,
      supportsVideo: false,
      supportsFiles: true,
    },
  ],
  webApplicationInfo: {
    id: "11111111-1111-1111-1111-111111111111",
  },
  authorization: {
    permissions: {
      resourceSpecific: [
        { name: "ChannelMessage.Read.Group", type: "Application" },
        { name: "ChannelMessage.Send.Group", type: "Application" },
        { name: "Member.Read.Group", type: "Application" },
        { name: "Owner.Read.Group", type: "Application" },
        { name: "ChannelSettings.Read.Group", type: "Application" },
        { name: "TeamMember.Read.Group", type: "Application" },
        { name: "TeamSettings.Read.Group", type: "Application" },
        { name: "ChatMessage.Read.Chat", type: "Application" },
      ],
    },
  },
}

​

Observações sobre o manifesto (campos obrigatórios)

• bots[].botId deve corresponder ao App ID do Azure Bot.
• webApplicationInfo.id deve corresponder ao App ID do Azure Bot.
• bots[].scopes deve incluir as superfícies que você pretende usar (personal, team, groupChat).
• bots[].supportsFiles: true é obrigatório para manipulação de arquivos no escopo pessoal.
• authorization.permissions.resourceSpecific deve incluir leitura/envio de canal se você quiser tráfego de canal.

​

Atualizando um aplicativo existente

1. Atualize seu manifest.json com as novas configurações
2. Incremente o campo version (por exemplo, 1.0.0 → 1.1.0)
3. Compacte novamente o manifesto com os ícones (manifest.json, outline.png, color.png)
4. Envie o novo zip:
   • Opção A (Teams Admin Center): Teams Admin Center → Teams apps → Manage apps → encontre seu aplicativo → Upload new version
   • Opção B (Sideload): No Teams → Apps → Manage your apps → Upload a custom app
5. Para canais de equipe: reinstale o aplicativo em cada equipe para que as novas permissões entrem em vigor
6. Feche completamente e reabra o Teams (não apenas feche a janela) para limpar os metadados em cache do aplicativo

​

Capacidades: somente RSC vs Graph

​

Com somente Teams RSC (aplicativo instalado, sem permissões da API Graph)

• Ler conteúdo de texto de mensagens do canal.
• Enviar conteúdo de texto para mensagens do canal.
• Receber anexos de arquivos em escopo pessoal (DM).

• Conteúdo de imagem ou arquivo de canal/grupo (a carga inclui apenas um stub HTML).
• Download de anexos armazenados no SharePoint/OneDrive.
• Leitura do histórico de mensagens (além do evento de webhook em tempo real).

​

Com Teams RSC + permissões de Aplicativo do Microsoft Graph

• Download de conteúdos hospedados (imagens coladas em mensagens).
• Download de anexos de arquivos armazenados no SharePoint/OneDrive.
• Leitura do histórico de mensagens de canal/chat via Graph.

​

RSC vs API Graph

​

Mídia + histórico com Graph ativado (obrigatório para canais)

1. No App Registration do Entra ID (Azure AD), adicione permissões de Aplicativo do Microsoft Graph:
   • ChannelMessage.Read.All (anexos de canal + histórico)
   • Chat.Read.All ou ChatMessage.Read.All (chats em grupo)
2. Conceda consentimento de administrador para o locatário.
3. Aumente a versão do manifesto do aplicativo Teams, envie novamente e reinstale o aplicativo no Teams.
4. Feche completamente e reabra o Teams para limpar os metadados em cache do aplicativo.

​

Limitações conhecidas

​

Timeouts de webhook

• Timeouts do gateway
• O Teams tentando reenviar a mensagem (causando duplicatas)
• Respostas descartadas

​

Formatação

• A formatação básica funciona: negrito, itálico, code, links
• Markdown complexo (tabelas, listas aninhadas) pode não ser renderizado corretamente
• Adaptive Cards são compatíveis para enquetes e envios arbitrários de cartões (consulte abaixo)

​

Configuração

• channels.msteams.enabled: ativa/desativa o canal.
• channels.msteams.appId, channels.msteams.appPassword, channels.msteams.tenantId: credenciais do bot.
• channels.msteams.webhook.port (padrão 3978)
• channels.msteams.webhook.path (padrão /api/messages)
• channels.msteams.dmPolicy: pairing | allowlist | open | disabled (padrão: pairing)
• channels.msteams.allowFrom: lista de permissões de DM (recomendam-se IDs de objeto AAD). O assistente resolve nomes para IDs durante a configuração quando o acesso ao Graph está disponível.
• channels.msteams.dangerouslyAllowNameMatching: opção de emergência para reativar a correspondência por UPN/nome de exibição mutáveis e o roteamento direto por nome de equipe/canal.
• channels.msteams.textChunkLimit: tamanho do bloco de texto de saída.
• channels.msteams.chunkMode: length (padrão) ou newline para dividir em linhas em branco (limites de parágrafo) antes da divisão por comprimento.
• channels.msteams.mediaAllowHosts: lista de permissões para hosts de anexos de entrada (por padrão, domínios da Microsoft/Teams).
• channels.msteams.mediaAuthAllowHosts: lista de permissões para anexar cabeçalhos Authorization em novas tentativas de mídia (por padrão, hosts do Graph + Bot Framework).
• channels.msteams.requireMention: exige @menção em canais/grupos (padrão: true).
• channels.msteams.replyStyle: thread | top-level (consulte Estilo de resposta).
• channels.msteams.teams.<teamId>.replyStyle: substituição por equipe.
• channels.msteams.teams.<teamId>.requireMention: substituição por equipe.
• channels.msteams.teams.<teamId>.tools: substituições padrão de política de ferramentas por equipe (allow/deny/alsoAllow) usadas quando não há uma substituição de canal.
• channels.msteams.teams.<teamId>.toolsBySender: substituições padrão de política de ferramentas por equipe e por remetente (compatível com curinga "*").
• channels.msteams.teams.<teamId>.channels.<conversationId>.replyStyle: substituição por canal.
• channels.msteams.teams.<teamId>.channels.<conversationId>.requireMention: substituição por canal.
• channels.msteams.teams.<teamId>.channels.<conversationId>.tools: substituições de política de ferramentas por canal (allow/deny/alsoAllow).
• channels.msteams.teams.<teamId>.channels.<conversationId>.toolsBySender: substituições de política de ferramentas por canal e por remetente (compatível com curinga "*").
• As chaves de toolsBySender devem usar prefixos explícitos: id:, e164:, username:, name: (chaves legadas sem prefixo ainda são mapeadas apenas para id:).
• channels.msteams.actions.memberInfo: ativa ou desativa a ação de informações de membro com suporte do Graph (padrão: ativada quando credenciais do Graph estão disponíveis).
• channels.msteams.authType: tipo de autenticação — "secret" (padrão) ou "federated".
• channels.msteams.certificatePath: caminho para o arquivo de certificado PEM (federada + autenticação por certificado).
• channels.msteams.certificateThumbprint: impressão digital do certificado (opcional, não obrigatória para autenticação).
• channels.msteams.useManagedIdentity: ativa autenticação por identidade gerenciada (modo federado).
• channels.msteams.managedIdentityClientId: ID do cliente para identidade gerenciada atribuída pelo usuário.
• channels.msteams.sharePointSiteId: ID do site do SharePoint para uploads de arquivos em chats/canais de grupo (consulte Envio de arquivos em chats de grupo).

​

Roteamento e sessões

• As chaves de sessão seguem o formato padrão de agente (consulte /concepts/session):
  • Mensagens diretas compartilham a sessão principal (agent:<agentId>:<mainKey>).
  • Mensagens de canal/grupo usam o ID da conversa:
    • agent:<agentId>:msteams:channel:<conversationId>
    • agent:<agentId>:msteams:group:<conversationId>

​

Estilo de resposta: threads vs publicações

• thread em um canal no estilo Threads → as respostas aparecem aninhadas de forma estranha
• top-level em um canal no estilo Posts → as respostas aparecem como publicações separadas de nível superior em vez de na thread

{
  channels: {
    msteams: {
      replyStyle: "thread",
      teams: {
        "19:abc...@thread.tacv2": {
          channels: {
            "19:xyz...@thread.tacv2": {
              replyStyle: "top-level",
            },
          },
        },
      },
    },
  },
}

​

Anexos e imagens

• DMs: imagens e anexos de arquivo funcionam por meio das APIs de arquivo do bot do Teams.
• Canais/grupos: anexos ficam armazenados no M365 (SharePoint/OneDrive). A carga útil do webhook inclui apenas um stub HTML, não os bytes reais do arquivo. Permissões da API Graph são obrigatórias para baixar anexos de canal.
• Para envios explícitos com arquivo primeiro, use action=upload-file com media / filePath / path; message opcional torna-se o texto/comentário que acompanha, e filename substitui o nome enviado.

​

Envio de arquivos em chats de grupo

​

Por que chats de grupo exigem SharePoint

​

Configuração

1. Adicione permissões da API Graph em Entra ID (Azure AD) → App Registration:
   • Sites.ReadWrite.All (Application) - enviar arquivos para o SharePoint
   • Chat.Read.All (Application) - opcional, ativa links de compartilhamento por usuário
2. Conceda consentimento de administrador para o locatário.
3. Obtenha o ID do seu site do SharePoint:
   # Via Graph Explorer ou curl com um token válido:
   curl -H "Authorization: Bearer $TOKEN" \
     "https://graph.microsoft.com/v1.0/sites/{hostname}:/{site-path}"
   
   # Exemplo: para um site em "contoso.sharepoint.com/sites/BotFiles"
   curl -H "Authorization: Bearer $TOKEN" \
     "https://graph.microsoft.com/v1.0/sites/contoso.sharepoint.com:/sites/BotFiles"
   
   # A resposta inclui: "id": "contoso.sharepoint.com,guid1,guid2"
   
4. Configure o OpenClaw:
   {
     channels: {
       msteams: {
         // ... other config ...
         sharePointSiteId: "contoso.sharepoint.com,guid1,guid2",
       },
     },
   }
   

​

Comportamento de compartilhamento

​

Comportamento de fallback

​

Local onde os arquivos são armazenados

​

Enquetes (Adaptive Cards)

• CLI: openclaw message poll --channel msteams --target conversation:<id> ...
• Os votos são registrados pelo gateway em ~/.openclaw/msteams-polls.json.
• O gateway deve permanecer online para registrar votos.
• As enquetes ainda não publicam automaticamente resumos de resultados (inspecione o arquivo de armazenamento, se necessário).

​

Adaptive Cards (arbitrários)

{
  action: "send",
  channel: "msteams",
  target: "user:<id>",
  card: {
    type: "AdaptiveCard",
    version: "1.5",
    body: [{ type: "TextBlock", text: "Hello!" }],
  },
}

openclaw message send --channel msteams \
  --target "conversation:19:abc...@thread.tacv2" \
  --card '{"type":"AdaptiveCard","version":"1.5","body":[{"type":"TextBlock","text":"Hello!"}]}'

​

Formatos de destino

# Enviar para um usuário por ID
openclaw message send --channel msteams --target "user:40a1a0ed-..." --message "Hello"

# Enviar para um usuário por nome de exibição (dispara consulta na API Graph)
openclaw message send --channel msteams --target "user:John Smith" --message "Hello"

# Enviar para um chat em grupo ou canal
openclaw message send --channel msteams --target "conversation:19:abc...@thread.tacv2" --message "Hello"

# Enviar um Adaptive Card para uma conversa
openclaw message send --channel msteams --target "conversation:19:abc...@thread.tacv2" \
  --card '{"type":"AdaptiveCard","version":"1.5","body":[{"type":"TextBlock","text":"Hello"}]}'

{
  action: "send",
  channel: "msteams",
  target: "user:John Smith",
  message: "Hello!",
}

{
  action: "send",
  channel: "msteams",
  target: "conversation:19:abc...@thread.tacv2",
  card: {
    type: "AdaptiveCard",
    version: "1.5",
    body: [{ type: "TextBlock", text: "Hello" }],
  },
}

​

Mensagens proativas

• Mensagens proativas só são possíveis depois que um usuário interagiu, porque armazenamos referências de conversa nesse momento.
• Consulte /gateway/configuration para dmPolicy e controle por lista de permissões.

​

IDs de equipe e canal (pegadinha comum)

https://teams.microsoft.com/l/team/19%3ABk4j...%40thread.tacv2/conversations?groupId=...
                                    └────────────────────────────┘
                                    ID da equipe (faça URL decode disso)

https://teams.microsoft.com/l/channel/19%3A15bc...%40thread.tacv2/ChannelName?groupId=...
                                      └─────────────────────────┘
                                      ID do canal (faça URL decode disso)

• ID da equipe = segmento do caminho após /team/ (decodificado da URL, por exemplo, 19:Bk4j...@thread.tacv2)
• ID do canal = segmento do caminho após /channel/ (decodificado da URL)
• Ignore o parâmetro de consulta groupId

​

Canais privados

1. Use canais padrão para interações com o bot
2. Use DMs - os usuários sempre podem enviar mensagens diretamente ao bot
3. Use a API Graph para acesso histórico (requer ChannelMessage.Read.All)

​

Solução de problemas

​

Problemas comuns

• Imagens não aparecem em canais: faltam permissões do Graph ou consentimento de administrador. Reinstale o aplicativo Teams e feche/reabra completamente o Teams.
• Sem respostas no canal: menções são obrigatórias por padrão; defina channels.msteams.requireMention=false ou configure por equipe/canal.
• Incompatibilidade de versão (o Teams ainda mostra o manifesto antigo): remova e adicione o aplicativo novamente e feche completamente o Teams para atualizar.
• 401 Unauthorized do webhook: esperado ao testar manualmente sem JWT do Azure - significa que o endpoint está acessível, mas a autenticação falhou. Use o Azure Web Chat para testar corretamente.

​

Erros no envio do manifesto

• “Icon file cannot be empty”: o manifesto faz referência a arquivos de ícone com 0 bytes. Crie ícones PNG válidos (32x32 para outline.png, 192x192 para color.png).
• “webApplicationInfo.Id already in use”: o aplicativo ainda está instalado em outra equipe/chat. Localize e desinstale-o primeiro ou aguarde de 5 a 10 minutos pela propagação.
• “Something went wrong” ao enviar: faça o envio por https://admin.teams.microsoft.com, abra as DevTools do navegador (F12) → aba Network e verifique o corpo da resposta para ver o erro real.
• Falha no sideload: tente “Upload an app to your org’s app catalog” em vez de “Upload a custom app” - isso geralmente contorna restrições de sideload.

​

Permissões RSC não funcionam

1. Verifique se webApplicationInfo.id corresponde exatamente ao App ID do seu bot
2. Envie novamente o aplicativo e reinstale-o na equipe/chat
3. Verifique se o administrador da sua organização bloqueou permissões RSC
4. Confirme se você está usando o escopo correto: ChannelMessage.Read.Group para equipes, ChatMessage.Read.Chat para chats em grupo

​

Referências

• Create Azure Bot - guia de configuração do Azure Bot
• Teams Developer Portal - criar/gerenciar aplicativos do Teams
• Teams app manifest schema
• Receive channel messages with RSC
• RSC permissions reference
• Teams bot file handling (canal/grupo requer Graph)
• Proactive messaging

​

Relacionado

• Visão geral dos canais — todos os canais compatíveis
• Pareamento — autenticação por DM e fluxo de pareamento
• Grupos — comportamento de chat em grupo e exigência de menção
• Roteamento de canal — roteamento de sessão para mensagens
• Segurança — modelo de acesso e proteção 강화