Microsoft Teams

Documentation Index

Fetch the complete documentation index at: https://docs.openclaw.ai/llms.txt

Use this file to discover all available pages before exploring further.

​

Plugin groupé

openclaw plugins install @openclaw/msteams

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

​

Configuration rapide

npm install -g @microsoft/teams.cli@preview
teams login
teams status   # verify you're logged in and see your tenant info

# One-time setup (persistent URL across sessions):
devtunnel create my-openclaw-bot --allow-anonymous
devtunnel port create my-openclaw-bot -p 3978 --protocol auto

# Each dev session:
devtunnel host my-openclaw-bot
# Your endpoint: https://<tunnel-id>.devtunnels.ms/api/messages

teams app create \
  --name "OpenClaw" \
  --endpoint "https://<your-tunnel-url>/api/messages"

• Crée une application Entra ID (Azure AD)
• Génère un secret client
• Construit et téléverse un manifeste d’application Teams (avec des icônes)
• Enregistre le bot (géré par Teams par défaut - aucun abonnement Azure nécessaire)

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

teams app get <teamsAppId> --install-link

teams app doctor <teamsAppId>

​

Objectifs

• Parler à OpenClaw via des DM, conversations de groupe ou canaux Teams.
• Garder le routage déterministe : les réponses reviennent toujours au canal d’où elles proviennent.
• Utiliser par défaut un comportement de canal sûr (mentions requises sauf configuration contraire).

​

Écritures de configuration

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

​

Contrôle d’accès (DM + groupes)

• Par défaut : channels.msteams.dmPolicy = "pairing". Les expéditeurs inconnus sont ignorés jusqu’à approbation.
• channels.msteams.allowFrom doit utiliser des ID d’objet AAD stables ou des groupes d’accès expéditeur statiques comme accessGroup:core-team.
• Ne vous appuyez pas sur la correspondance UPN/nom d’affichage pour les listes d’autorisation - ils peuvent changer. OpenClaw désactive par défaut la correspondance directe par nom ; activez-la explicitement avec channels.msteams.dangerouslyAllowNameMatching: true.
• L’assistant peut résoudre les noms en ID via Microsoft Graph lorsque les identifiants le permettent.

• Par défaut : channels.msteams.groupPolicy = "allowlist" (bloqué sauf si vous ajoutez groupAllowFrom). Utilisez channels.defaults.groupPolicy pour remplacer la valeur par défaut lorsqu’elle n’est pas définie.
• channels.msteams.groupAllowFrom contrôle quels expéditeurs ou groupes d’accès expéditeur statiques peuvent déclencher dans les conversations de groupe/canaux (avec repli sur channels.msteams.allowFrom).
• Définissez groupPolicy: "open" pour autoriser n’importe quel membre (toujours avec mention obligatoire par défaut).
• Pour n’autoriser aucun canal, définissez channels.msteams.groupPolicy: "disabled".

{
  channels: {
    msteams: {
      groupPolicy: "allowlist",
      groupAllowFrom: ["00000000-0000-0000-0000-000000000000", "accessGroup:core-team"],
    },
  },
}

• Limitez la portée des réponses de groupe/canal en listant les équipes et canaux sous channels.msteams.teams.
• Les clés doivent utiliser des ID de conversation Teams stables issus des liens Teams, et non des noms d’affichage modifiables.
• Lorsque groupPolicy="allowlist" et qu’une liste d’autorisation d’équipes est présente, seuls les équipes/canaux listés sont acceptés (avec mention obligatoire).
• L’assistant de configuration accepte les entrées Team/Channel et les stocke pour vous.
• Au démarrage, OpenClaw résout les noms de liste d’autorisation d’équipe/canal et d’utilisateur en ID (lorsque les permissions Graph le permettent) et journalise la correspondance ; les noms d’équipe/canal non résolus sont conservés tels que saisis, mais ignorés par défaut pour le routage sauf si channels.msteams.dangerouslyAllowNameMatching: true est activé.

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

​

Authentification fédérée (certificat plus identité managée)

Ajouté dans 2026.4.11

​

Option A : authentification basée sur certificat

1. Générez ou obtenez un certificat (format PEM avec clé privée).
2. Dans Entra ID → Inscription d’application → Certificates & secrets → Certificates → téléversez le certificat public.

{
  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

​

Option B : identité managée Azure

1. Le pod/la VM du bot possède une identité managée (attribuée par le système ou par l’utilisateur).
2. Un identifiant d’identité fédérée lie l’identité managée à l’inscription d’application Entra ID.
3. À l’exécution, OpenClaw utilise @azure/identity pour acquérir des jetons depuis le point de terminaison Azure IMDS (169.254.169.254).
4. Le jeton est transmis au SDK Teams pour l’authentification du bot.

• Infrastructure Azure avec identité managée activée (identité de charge de travail AKS, App Service, VM)
• Identifiant d’identité fédérée créé sur l’inscription d’application Entra ID
• Accès réseau à IMDS (169.254.169.254:80) depuis le pod/la 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> (uniquement pour l’identité attribuée par l’utilisateur)

​

Configuration de l’identité de charge de travail AKS

1. Activez l’identité de charge de travail sur votre cluster AKS.
2. Créez un identifiant d’identité fédérée sur l’inscription de l’application 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. Annotez le compte de service Kubernetes avec l’ID client de l’application :
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: my-bot-sa
     annotations:
       azure.workload.identity/client-id: "<APP_CLIENT_ID>"
   
4. Étiquetez le pod pour l’injection de l’identité de charge de travail :
   metadata:
     labels:
       azure.workload.identity/use: "true"
   
5. Assurez l’accès réseau à IMDS (169.254.169.254) - si vous utilisez NetworkPolicy, ajoutez une règle de sortie autorisant le trafic vers 169.254.169.254/32 sur le port 80.

​

Comparaison des types d’authentification

​

Développement local (tunnel)

# One-time setup:
devtunnel create my-openclaw-bot --allow-anonymous
devtunnel port create my-openclaw-bot -p 3978 --protocol auto

# Each dev session:
devtunnel host my-openclaw-bot

teams app update <teamsAppId> --endpoint "https://<new-url>/api/messages"

​

Tester le bot

teams app doctor <teamsAppId>

1. Installez l’application Teams (utilisez le lien d’installation depuis teams app get <id> --install-link)
2. Trouvez le bot dans Teams et envoyez-lui un message direct
3. Vérifiez les journaux du Gateway pour l’activité entrante

​

Variables d’environnement

• MSTEAMS_APP_ID
• MSTEAMS_APP_PASSWORD
• MSTEAMS_TENANT_ID
• MSTEAMS_AUTH_TYPE (facultatif : "secret" ou "federated")
• MSTEAMS_CERTIFICATE_PATH (fédéré + certificat)
• MSTEAMS_CERTIFICATE_THUMBPRINT (facultatif, non requis pour l’authentification)
• MSTEAMS_USE_MANAGED_IDENTITY (fédéré + identité managée)
• MSTEAMS_MANAGED_IDENTITY_CLIENT_ID (MI attribuée par l’utilisateur uniquement)

​

Action d’informations sur les membres

• Permission RSC Member.Read.Group (déjà présente dans le manifeste recommandé)
• Pour les recherches entre équipes : permission d’application Graph User.Read.All avec consentement administrateur

​

Contexte de l’historique

• channels.msteams.historyLimit contrôle le nombre de messages récents de canal/groupe inclus dans le prompt.
• Se rabat sur messages.groupChat.historyLimit. Définissez 0 pour désactiver (50 par défaut).
• L’historique de fil récupéré est filtré par les listes d’autorisation d’expéditeurs (allowFrom / groupAllowFrom), de sorte que l’amorçage du contexte de fil inclut uniquement les messages provenant d’expéditeurs autorisés.
• Le contexte des pièces jointes citées (ReplyTo* dérivé du HTML de réponse Teams) est actuellement transmis tel qu’il est reçu.
• En d’autres termes, les listes d’autorisation contrôlent qui peut déclencher l’agent ; seuls certains chemins de contexte supplémentaires sont filtrés aujourd’hui.
• L’historique des messages directs peut être limité avec channels.msteams.dmHistoryLimit (tours utilisateur). Remplacements par utilisateur : channels.msteams.dms["<user_id>"].historyLimit.

​

Permissions RSC Teams actuelles (manifeste)

• ChannelMessage.Read.Group (Application) - recevoir tous les messages de canal sans @mention
• 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) - recevoir tous les messages de chat de groupe sans @mention

teams app rsc add <teamsAppId> ChannelMessage.Read.Group --type Application

​

Exemple de manifeste Teams (expurgé)

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

​

Mises en garde sur le manifeste (champs indispensables)

• bots[].botId doit correspondre à l’ID de l’application Azure Bot.
• webApplicationInfo.id doit correspondre à l’ID de l’application Azure Bot.
• bots[].scopes doit inclure les surfaces que vous prévoyez d’utiliser (personal, team, groupChat).
• bots[].supportsFiles: true est requis pour la gestion des fichiers dans le périmètre personnel.
• authorization.permissions.resourceSpecific doit inclure la lecture/l’envoi de canal si vous voulez du trafic de canal.

​

Mettre à jour une application existante

# Download, edit, and re-upload the manifest
teams app manifest download <teamsAppId> manifest.json
# Edit manifest.json locally...
teams app manifest upload manifest.json <teamsAppId>
# Version is auto-bumped if content changed

​

Fonctionnalités : RSC uniquement contre Graph

​

Avec Teams RSC uniquement (application installée, aucune permission Graph API)

• Lire le contenu texte des messages de canal.
• Envoyer du contenu texte dans un message de canal.
• Recevoir des pièces jointes dans les fichiers personnels (DM).

• Contenu d’image ou de fichier de canal/groupe (la charge utile inclut seulement un fragment HTML).
• Téléchargement des pièces jointes stockées dans SharePoint/OneDrive.
• Lecture de l’historique des messages (au-delà de l’événement Webhook en direct).

​

Avec Teams RSC + permissions d’application Microsoft Graph

• Téléchargement des contenus hébergés (images collées dans les messages).
• Téléchargement des pièces jointes de fichiers stockées dans SharePoint/OneDrive.
• Lecture de l’historique des messages de canal/chat via Graph.

​

RSC contre Graph API

​

Médias et historique activés par Graph (requis pour les canaux)

1. Dans l’inscription de l’application Entra ID (Azure AD), ajoutez les permissions d’application Microsoft Graph :
   • ChannelMessage.Read.All (pièces jointes de canal + historique)
   • Chat.Read.All ou ChatMessage.Read.All (chats de groupe)
2. Accordez le consentement administrateur pour le locataire.
3. Augmentez la version du manifeste de l’application Teams, rechargez-le et réinstallez l’application dans Teams.
4. Quittez complètement puis relancez Teams pour effacer les métadonnées d’application mises en cache.

​

Limitations connues

​

Expirations de délai du Webhook

• Expirations de délai du Gateway
• Teams qui réessaie le message (ce qui provoque des doublons)
• Réponses abandonnées

​

Mise en forme

• La mise en forme de base fonctionne : gras, italique, code, liens
• Le markdown complexe (tableaux, listes imbriquées) peut ne pas s’afficher correctement
• Les Adaptive Cards sont prises en charge pour les sondages et les envois de présentation sémantique (voir ci-dessous)

​

Configuration

• channels.msteams.enabled : activer/désactiver le canal.
• channels.msteams.appId, channels.msteams.appPassword, channels.msteams.tenantId : identifiants du bot.
• channels.msteams.webhook.port (par défaut 3978)
• channels.msteams.webhook.path (par défaut /api/messages)
• channels.msteams.dmPolicy : pairing | allowlist | open | disabled (par défaut : pairing)
• channels.msteams.allowFrom : liste d’autorisation des DM (ID d’objets AAD recommandés). L’assistant résout les noms en ID pendant la configuration lorsque l’accès à Graph est disponible.
• channels.msteams.dangerouslyAllowNameMatching : bascule de dernier recours pour réactiver la correspondance mutable par UPN/nom d’affichage et le routage direct par nom d’équipe/canal.
• channels.msteams.textChunkLimit : taille des segments de texte sortants.
• channels.msteams.chunkMode : length (par défaut) ou newline pour découper sur les lignes vides (limites de paragraphes) avant le découpage par longueur.
• channels.msteams.mediaAllowHosts : liste d’autorisation des hôtes de pièces jointes entrantes (par défaut les domaines Microsoft/Teams).
• channels.msteams.mediaAuthAllowHosts : liste d’autorisation des hôtes pour ajouter les en-têtes Authorization lors des nouvelles tentatives média (par défaut les hôtes Graph + Bot Framework).
• channels.msteams.requireMention : exiger une @mention dans les canaux/groupes (par défaut true).
• channels.msteams.replyStyle : thread | top-level (voir Style de réponse).
• channels.msteams.teams.<teamId>.replyStyle : remplacement par équipe.
• channels.msteams.teams.<teamId>.requireMention : remplacement par équipe.
• channels.msteams.teams.<teamId>.tools : remplacements par défaut de la politique d’outils par équipe (allow/deny/alsoAllow) utilisés lorsqu’un remplacement de canal est absent.
• channels.msteams.teams.<teamId>.toolsBySender : remplacements par défaut de la politique d’outils par expéditeur et par équipe (joker "*" pris en charge).
• channels.msteams.teams.<teamId>.channels.<conversationId>.replyStyle : remplacement par canal.
• channels.msteams.teams.<teamId>.channels.<conversationId>.requireMention : remplacement par canal.
• channels.msteams.teams.<teamId>.channels.<conversationId>.tools : remplacements de la politique d’outils par canal (allow/deny/alsoAllow).
• channels.msteams.teams.<teamId>.channels.<conversationId>.toolsBySender : remplacements de la politique d’outils par expéditeur et par canal (joker "*" pris en charge).
• Les clés toolsBySender doivent utiliser des préfixes explicites : channel:, id:, e164:, username:, name: (les anciennes clés sans préfixe correspondent encore uniquement à id:).
• channels.msteams.actions.memberInfo : activer ou désactiver l’action d’informations sur les membres adossée à Graph (par défaut : activée lorsque les identifiants Graph sont disponibles).
• channels.msteams.authType : type d’authentification - "secret" (par défaut) ou "federated".
• channels.msteams.certificatePath : chemin vers le fichier de certificat PEM (authentification fédérée + certificat).
• channels.msteams.certificateThumbprint : empreinte du certificat (facultative, non requise pour l’authentification).
• channels.msteams.useManagedIdentity : activer l’authentification par identité managée (mode fédéré).
• channels.msteams.managedIdentityClientId : ID client pour l’identité managée attribuée par l’utilisateur.
• channels.msteams.sharePointSiteId : ID du site SharePoint pour les téléversements de fichiers dans les discussions de groupe/canaux (voir Envoyer des fichiers dans les discussions de groupe).

​

Routage et sessions

• Les clés de session suivent le format standard des agents (voir /concepts/session) :
  • Les messages directs partagent la session principale (agent:<agentId>:<mainKey>).
  • Les messages de canal/groupe utilisent l’id de conversation :
    • agent:<agentId>:msteams:channel:<conversationId>
    • agent:<agentId>:msteams:group:<conversationId>

​

Style de réponse : fils de discussion ou publications

• thread dans un canal de style Fils → les réponses apparaissent imbriquées de façon maladroite
• top-level dans un canal de style Publications → les réponses apparaissent comme des publications de premier niveau distinctes au lieu d’être dans le fil

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

​

Priorité de résolution

1. Par canal — channels.msteams.teams.<teamId>.channels.<conversationId>.replyStyle
2. Par équipe — channels.msteams.teams.<teamId>.replyStyle
3. Global — channels.msteams.replyStyle
4. Valeur implicite par défaut — dérivée de requireMention :
   • requireMention: true → thread
   • requireMention: false → top-level

​

Conservation du contexte de fil

​

Pièces jointes et images

• DM : les images et pièces jointes de fichiers fonctionnent via les API de fichiers du bot Teams.
• Canaux/groupes : les pièces jointes résident dans le stockage M365 (SharePoint/OneDrive). La charge utile du Webhook ne contient qu’un extrait HTML, pas les octets réels du fichier. Des autorisations Graph API sont requises pour télécharger les pièces jointes de canal.
• Pour les envois explicites centrés sur un fichier, utilisez action=upload-file avec media / filePath / path ; le message facultatif devient le texte/commentaire d’accompagnement, et filename remplace le nom téléversé.

​

Envoyer des fichiers dans les discussions de groupe

​

Pourquoi les discussions de groupe ont besoin de SharePoint

​

Configuration

1. Ajoutez les autorisations Graph API dans Entra ID (Azure AD) → App Registration :
   • Sites.ReadWrite.All (Application) - téléverser des fichiers vers SharePoint
   • Chat.Read.All (Application) - facultatif, active les liens de partage par utilisateur
2. Accordez le consentement administrateur pour le locataire.
3. Obtenez l’ID de votre site SharePoint :
   # Via Graph Explorer or curl with a valid token:
   curl -H "Authorization: Bearer $TOKEN" \
     "https://graph.microsoft.com/v1.0/sites/{hostname}:/{site-path}"
   
   # Example: for a site at "contoso.sharepoint.com/sites/BotFiles"
   curl -H "Authorization: Bearer $TOKEN" \
     "https://graph.microsoft.com/v1.0/sites/contoso.sharepoint.com:/sites/BotFiles"
   
   # Response includes: "id": "contoso.sharepoint.com,guid1,guid2"
   
4. Configurez OpenClaw :
   {
     channels: {
       msteams: {
         // ... other config ...
         sharePointSiteId: "contoso.sharepoint.com,guid1,guid2",
       },
     },
   }
   

​

Comportement de partage

​

Comportement de repli

​

Emplacement de stockage des fichiers

​

Sondages (Adaptive Cards)

• CLI : openclaw message poll --channel msteams --target conversation:<id> ...
• Les votes sont enregistrés par le Gateway dans ~/.openclaw/msteams-polls.json.
• Le Gateway doit rester en ligne pour enregistrer les votes.
• Les sondages ne publient pas encore automatiquement de résumés de résultats (inspectez le fichier de stockage si nécessaire).

​

Cartes de présentation

{
  action: "send",
  channel: "msteams",
  target: "user:<id>",
  presentation: {
    title: "Hello",
    blocks: [{ type: "text", text: "Hello!" }],
  },
}

openclaw message send --channel msteams \
  --target "conversation:19:abc...@thread.tacv2" \
  --presentation '{"title":"Hello","blocks":[{"type":"text","text":"Hello!"}]}'

​

Formats des cibles

# Send to a user by ID
openclaw message send --channel msteams --target "user:40a1a0ed-..." --message "Hello"

# Send to a user by display name (triggers Graph API lookup)
openclaw message send --channel msteams --target "user:John Smith" --message "Hello"

# Send to a group chat or channel
openclaw message send --channel msteams --target "conversation:19:abc...@thread.tacv2" --message "Hello"

# Send a presentation card to a conversation
openclaw message send --channel msteams --target "conversation:19:abc...@thread.tacv2" \
  --presentation '{"title":"Hello","blocks":[{"type":"text","text":"Hello"}]}'

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

{
  action: "send",
  channel: "msteams",
  target: "conversation:19:abc...@thread.tacv2",
  presentation: {
    title: "Hello",
    blocks: [{ type: "text", text: "Hello" }],
  },
}

​

Messagerie proactive

• Les messages proactifs ne sont possibles qu’après qu’un utilisateur a interagi, car nous stockons alors les références de conversation.
• Consultez /gateway/configuration pour dmPolicy et le filtrage par liste d’autorisation.

​

ID d’équipe et de canal (piège courant)

https://teams.microsoft.com/l/team/19%3ABk4j...%40thread.tacv2/conversations?groupId=...
                                    └────────────────────────────┘
                                    Team conversation ID (URL-decode this)

https://teams.microsoft.com/l/channel/19%3A15bc...%40thread.tacv2/ChannelName?groupId=...
                                      └─────────────────────────┘
                                      Channel ID (URL-decode this)

• Clé d’équipe = segment de chemin après /team/ (décodé depuis l’URL, par exemple 19:Bk4j...@thread.tacv2 ; les anciens tenants peuvent afficher @thread.skype, qui est également valide)
• Clé de canal = segment de chemin après /channel/ (décodé depuis l’URL)
• Ignorez le paramètre de requête groupId pour le routage OpenClaw. Il s’agit de l’ID de groupe Microsoft Entra, et non de l’ID de conversation Bot Framework utilisé dans les activités Teams entrantes.

​

Canaux privés

1. Utilisez des canaux standard pour les interactions avec le bot
2. Utilisez les DM : les utilisateurs peuvent toujours envoyer un message directement au bot
3. Utilisez Graph API pour l’accès à l’historique (nécessite ChannelMessage.Read.All)

​

Dépannage

​

Problèmes courants

• Images absentes dans les canaux : autorisations Graph ou consentement administrateur manquants. Réinstallez l’application Teams et quittez/réouvrez complètement Teams.
• Aucune réponse dans le canal : les mentions sont requises par défaut ; définissez channels.msteams.requireMention=false ou configurez par équipe/canal.
• Incompatibilité de version (Teams affiche encore l’ancien manifeste) : supprimez puis rajoutez l’application, et quittez complètement Teams pour l’actualiser.
• 401 Unauthorized depuis le webhook : attendu lors d’un test manuel sans JWT Azure ; cela signifie que le point de terminaison est joignable, mais que l’authentification a échoué. Utilisez Azure Web Chat pour tester correctement.

​

Erreurs de téléversement du manifeste

• “Icon file cannot be empty” : le manifeste référence des fichiers d’icônes de 0 octet. Créez des icônes PNG valides (32x32 pour outline.png, 192x192 pour color.png).
• “webApplicationInfo.Id already in use” : l’application est encore installée dans une autre équipe/conversation. Trouvez-la et désinstallez-la d’abord, ou attendez 5 à 10 minutes pour la propagation.
• “Something went wrong” lors du téléversement : téléversez plutôt via https://admin.teams.microsoft.com, ouvrez les DevTools du navigateur (F12) → onglet Network, puis vérifiez le corps de la réponse pour l’erreur réelle.
• Échec du sideload : essayez “Upload an app to your org’s app catalog” au lieu de “Upload a custom app” ; cela contourne souvent les restrictions de sideload.

​

Les autorisations RSC ne fonctionnent pas

1. Vérifiez que webApplicationInfo.id correspond exactement à l’App ID de votre bot
2. Retéléversez l’application et réinstallez-la dans l’équipe/conversation
3. Vérifiez si l’administrateur de votre organisation a bloqué les autorisations RSC
4. Confirmez que vous utilisez la bonne portée : ChannelMessage.Read.Group pour les équipes, ChatMessage.Read.Chat pour les conversations de groupe

​

Références

• Créer un Azure Bot - guide de configuration Azure Bot
• Teams Developer Portal - créer/gérer des applications Teams
• Schéma de manifeste d’application Teams
• Recevoir les messages de canal avec RSC
• Référence des autorisations RSC
• Gestion des fichiers par les bots Teams (canal/groupe nécessite Graph)
• Messagerie proactive
• @microsoft/teams.cli - CLI Teams pour la gestion des bots

​

Connexe

• Vue d’ensemble des canaux - tous les canaux pris en charge
• Appairage - authentification par DM et flux d’appairage
• Groupes - comportement des conversations de groupe et filtrage par mention
• Routage des canaux - routage de session pour les messages
• Sécurité - modèle d’accès et durcissement