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.

​

Gebündeltes Plugin

openclaw plugins install @openclaw/msteams

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

​

Schnelle Einrichtung

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"

• Erstellt eine Entra ID (Azure AD)-Anwendung
• Generiert ein Client Secret
• Erstellt ein Teams-App-Manifest (mit Icons) und lädt es hoch
• Registriert den Bot (standardmäßig von Teams verwaltet - kein Azure-Abonnement erforderlich)

{
  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>

​

Ziele

• Mit OpenClaw über Teams-DMs, Gruppenchats oder Kanäle sprechen.
• Routing deterministisch halten: Antworten gehen immer an den Kanal zurück, über den sie eingegangen sind.
• Standardmäßig sicheres Kanalverhalten verwenden (Erwähnungen erforderlich, sofern nicht anders konfiguriert).

​

Konfigurationsschreibvorgänge

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

​

Zugriffskontrolle (DMs + Gruppen)

• Standard: channels.msteams.dmPolicy = "pairing". Unbekannte Absender werden ignoriert, bis sie genehmigt sind.
• channels.msteams.allowFrom sollte stabile AAD-Objekt-IDs oder statische Absender-Zugriffsgruppen wie accessGroup:core-team verwenden.
• Verlassen Sie sich für Allowlists nicht auf UPN-/Anzeigenamen-Abgleich - diese können sich ändern. OpenClaw deaktiviert direkten Namensabgleich standardmäßig; aktivieren Sie ihn explizit mit channels.msteams.dangerouslyAllowNameMatching: true.
• Der Assistent kann Namen über Microsoft Graph in IDs auflösen, wenn die Anmeldedaten dies zulassen.

• Standard: channels.msteams.groupPolicy = "allowlist" (blockiert, sofern Sie groupAllowFrom nicht hinzufügen). Verwenden Sie channels.defaults.groupPolicy, um den Standard zu überschreiben, wenn er nicht gesetzt ist.
• channels.msteams.groupAllowFrom steuert, welche Absender oder statischen Absender-Zugriffsgruppen in Gruppenchats/Kanälen auslösen dürfen (fällt auf channels.msteams.allowFrom zurück).
• Setzen Sie groupPolicy: "open", um jedes Mitglied zuzulassen (standardmäßig weiterhin durch Erwähnung begrenzt).
• Um keine Kanäle zuzulassen, setzen Sie channels.msteams.groupPolicy: "disabled".

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

• Begrenzen Sie Gruppen-/Kanalantworten, indem Sie Teams und Kanäle unter channels.msteams.teams auflisten.
• Schlüssel sollten stabile Teams-Unterhaltungs-IDs aus Teams-Links verwenden, keine veränderlichen Anzeigenamen.
• Wenn groupPolicy="allowlist" und eine Teams-Allowlist vorhanden ist, werden nur aufgelistete Teams/Kanäle akzeptiert (durch Erwähnung begrenzt).
• Der Konfigurationsassistent akzeptiert Team/Channel-Einträge und speichert sie für Sie.
• Beim Start löst OpenClaw Team-/Kanal- und Benutzer-Allowlist-Namen in IDs auf (wenn Graph-Berechtigungen dies zulassen) und protokolliert die Zuordnung; nicht aufgelöste Team-/Kanalnamen werden wie eingegeben beibehalten, aber standardmäßig für das Routing ignoriert, sofern channels.msteams.dangerouslyAllowNameMatching: true nicht aktiviert ist.

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

​

Föderierte Authentifizierung (Zertifikat plus verwaltete Identität)

Hinzugefügt in 2026.4.11

​

Option A: Zertifikatbasierte Authentifizierung

1. Generieren oder beschaffen Sie ein Zertifikat (PEM-Format mit privatem Schlüssel).
2. In Entra ID → App-Registrierung → Certificates & secrets → Certificates → laden Sie das öffentliche Zertifikat hoch.

{
  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: Azure Managed Identity

1. Der Bot-Pod/die VM verfügt über eine verwaltete Identität (systemseitig zugewiesen oder benutzerseitig zugewiesen).
2. Ein federated identity credential verknüpft die verwaltete Identität mit der Entra ID-App-Registrierung.
3. Zur Laufzeit verwendet OpenClaw @azure/identity, um Tokens vom Azure IMDS-Endpunkt (169.254.169.254) abzurufen.
4. Das Token wird zur Bot-Authentifizierung an das Teams SDK übergeben.

• Azure-Infrastruktur mit aktivierter verwalteter Identität (AKS Workload Identity, App Service, VM)
• Federated Identity Credential, das in der Entra ID-App-Registrierung erstellt wurde
• Netzwerkzugriff auf IMDS (169.254.169.254:80) vom Pod/von der 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> (nur für benutzerzugewiesene)

​

Einrichtung der AKS Workload Identity

1. Aktivieren Sie Workload Identity in Ihrem AKS-Cluster.
2. Erstellen Sie eine föderierte Identitätsanmeldeinformation in der Entra ID-App-Registrierung:
   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. Annotieren Sie das Kubernetes-Dienstkonto mit der App-Client-ID:
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: my-bot-sa
     annotations:
       azure.workload.identity/client-id: "<APP_CLIENT_ID>"
   
4. Kennzeichnen Sie den Pod für die Injektion der Workload Identity:
   metadata:
     labels:
       azure.workload.identity/use: "true"
   
5. Stellen Sie den Netzwerkzugriff auf IMDS (169.254.169.254) sicher. Wenn Sie NetworkPolicy verwenden, fügen Sie eine Egress-Regel hinzu, die Datenverkehr zu 169.254.169.254/32 auf Port 80 zulässt.

​

Vergleich der Authentifizierungstypen

​

Lokale Entwicklung (Tunneling)

# 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"

​

Bot testen

teams app doctor <teamsAppId>

1. Installieren Sie die Teams-App (verwenden Sie den Installationslink aus teams app get <id> --install-link)
2. Suchen Sie den Bot in Teams und senden Sie eine DM
3. Prüfen Sie die Gateway-Protokolle auf eingehende Aktivität

​

Umgebungsvariablen

• MSTEAMS_APP_ID
• MSTEAMS_APP_PASSWORD
• MSTEAMS_TENANT_ID
• MSTEAMS_AUTH_TYPE (optional: "secret" oder "federated")
• MSTEAMS_CERTIFICATE_PATH (föderiert + Zertifikat)
• MSTEAMS_CERTIFICATE_THUMBPRINT (optional, für Authentifizierung nicht erforderlich)
• MSTEAMS_USE_MANAGED_IDENTITY (föderiert + Managed Identity)
• MSTEAMS_MANAGED_IDENTITY_CLIENT_ID (nur benutzerzugewiesene MI)

​

Aktion für Mitgliedsinformationen

• Member.Read.Group-RSC-Berechtigung (bereits im empfohlenen Manifest enthalten)
• Für teamübergreifende Suchvorgänge: User.Read.All-Graph-Anwendungsberechtigung mit Administratoreinwilligung

​

Verlaufskontext

• channels.msteams.historyLimit steuert, wie viele aktuelle Kanal-/Gruppennachrichten in den Prompt eingebunden werden.
• Fällt auf messages.groupChat.historyLimit zurück. Setzen Sie 0, um dies zu deaktivieren (Standard 50).
• Der abgerufene Thread-Verlauf wird nach Absender-Zulassungslisten (allowFrom / groupAllowFrom) gefiltert, sodass die Initialisierung des Thread-Kontexts nur Nachrichten von erlaubten Absendern enthält.
• Zitierter Anhangskontext (aus Teams-Antwort-HTML abgeleitetes ReplyTo*) wird derzeit unverändert weitergegeben.
• Anders gesagt: Zulassungslisten steuern, wer den Agenten auslösen kann; derzeit werden nur bestimmte ergänzende Kontextpfade gefiltert.
• Der DM-Verlauf kann mit channels.msteams.dmHistoryLimit begrenzt werden (Benutzer-Turns). Pro-Benutzer-Überschreibungen: channels.msteams.dms["<user_id>"].historyLimit.

​

Aktuelle Teams-RSC-Berechtigungen (Manifest)

• ChannelMessage.Read.Group (Anwendung) - alle Kanalnachrichten ohne @mention empfangen
• ChannelMessage.Send.Group (Anwendung)
• Member.Read.Group (Anwendung)
• Owner.Read.Group (Anwendung)
• ChannelSettings.Read.Group (Anwendung)
• TeamMember.Read.Group (Anwendung)
• TeamSettings.Read.Group (Anwendung)

• ChatMessage.Read.Chat (Anwendung) - alle Gruppenchatnachrichten ohne @mention empfangen

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

​

Beispiel für ein Teams-Manifest (redigiert)

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

​

Manifest-Hinweise (erforderliche Felder)

• bots[].botId muss mit der Azure Bot-App-ID übereinstimmen.
• webApplicationInfo.id muss mit der Azure Bot-App-ID übereinstimmen.
• bots[].scopes muss die Oberflächen enthalten, die Sie verwenden möchten (personal, team, groupChat).
• bots[].supportsFiles: true ist für die Dateiverarbeitung im persönlichen Scope erforderlich.
• authorization.permissions.resourceSpecific muss Lesen/Senden für Kanäle enthalten, wenn Sie Kanalverkehr nutzen möchten.

​

Eine vorhandene App aktualisieren

# 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

​

Funktionen: nur RSC vs. Graph

​

Mit nur Teams RSC (App installiert, keine Graph API-Berechtigungen)

• Textinhalt von Kanalnachrichten lesen.
• Textinhalt von Kanalnachrichten senden.
• Dateianhänge in persönlichen Nachrichten (DM) empfangen.

• Bild- oder Dateiinhalte in Kanälen/Gruppen (Payload enthält nur HTML-Stub).
• Herunterladen von in SharePoint/OneDrive gespeicherten Anhängen.
• Lesen des Nachrichtenverlaufs (über das Live-Webhook-Ereignis hinaus).

​

Mit Teams RSC + Microsoft Graph-Anwendungsberechtigungen

• Herunterladen gehosteter Inhalte (in Nachrichten eingefügte Bilder).
• Herunterladen von in SharePoint/OneDrive gespeicherten Dateianhängen.
• Lesen des Kanal-/Chatnachrichtenverlaufs über Graph.

​

RSC vs. Graph API

​

Graph-aktivierte Medien + Verlauf (für Kanäle erforderlich)

1. Fügen Sie in der Entra ID (Azure AD) App-Registrierung Microsoft Graph-Anwendungsberechtigungen hinzu:
   • ChannelMessage.Read.All (Kanalanhänge + Verlauf)
   • Chat.Read.All oder ChatMessage.Read.All (Gruppenchats)
2. Erteilen Sie Administratoreinwilligung für den Mandanten.
3. Erhöhen Sie die Manifestversion der Teams-App, laden Sie sie erneut hoch und installieren Sie die App in Teams neu.
4. Beenden Sie Teams vollständig und starten Sie es neu, um zwischengespeicherte App-Metadaten zu löschen.

​

Bekannte Einschränkungen

​

Webhook-Zeitüberschreitungen

• Gateway-Zeitüberschreitungen
• Teams versucht erneut, die Nachricht zuzustellen (führt zu Duplikaten)
• Verworfene Antworten

​

Formatierung

• Grundlegende Formatierung funktioniert: fett, kursiv, code, Links
• Komplexes Markdown (Tabellen, verschachtelte Listen) wird möglicherweise nicht korrekt dargestellt
• Adaptive Cards werden für Umfragen und semantische Präsentationssendungen unterstützt (siehe unten)

​

Konfiguration

• channels.msteams.enabled: Kanal aktivieren/deaktivieren.
• channels.msteams.appId, channels.msteams.appPassword, channels.msteams.tenantId: Bot-Anmeldedaten.
• channels.msteams.webhook.port (Standard 3978)
• channels.msteams.webhook.path (Standard /api/messages)
• channels.msteams.dmPolicy: pairing | allowlist | open | disabled (Standard: Pairing)
• channels.msteams.allowFrom: DM-Allowlist (AAD-Objekt-IDs empfohlen). Der Assistent löst Namen während der Einrichtung in IDs auf, wenn Graph-Zugriff verfügbar ist.
• channels.msteams.dangerouslyAllowNameMatching: Notfall-Umschalter, um änderbares UPN-/Anzeigenamen-Matching und direktes Routing nach Team-/Kanalnamen wieder zu aktivieren.
• channels.msteams.textChunkLimit: Blockgröße für ausgehenden Text.
• channels.msteams.chunkMode: length (Standard) oder newline, um vor der längenbasierten Aufteilung an Leerzeilen (Absatzgrenzen) zu trennen.
• channels.msteams.mediaAllowHosts: Allowlist für eingehende Anhang-Hosts (standardmäßig Microsoft-/Teams-Domains).
• channels.msteams.mediaAuthAllowHosts: Allowlist für das Anhängen von Authorization-Headern bei Medien-Wiederholungen (standardmäßig Graph- und Bot-Framework-Hosts).
• channels.msteams.requireMention: @Mention in Kanälen/Gruppen verlangen (Standard true).
• channels.msteams.replyStyle: thread | top-level (siehe Antwortstil).
• channels.msteams.teams.<teamId>.replyStyle: Überschreibung pro Team.
• channels.msteams.teams.<teamId>.requireMention: Überschreibung pro Team.
• channels.msteams.teams.<teamId>.tools: Standardmäßige Tool-Richtlinienüberschreibungen pro Team (allow/deny/alsoAllow), die verwendet werden, wenn eine Kanalüberschreibung fehlt.
• channels.msteams.teams.<teamId>.toolsBySender: Standardmäßige Tool-Richtlinienüberschreibungen pro Team und Absender ("*"-Wildcard unterstützt).
• channels.msteams.teams.<teamId>.channels.<conversationId>.replyStyle: Überschreibung pro Kanal.
• channels.msteams.teams.<teamId>.channels.<conversationId>.requireMention: Überschreibung pro Kanal.
• channels.msteams.teams.<teamId>.channels.<conversationId>.tools: Tool-Richtlinienüberschreibungen pro Kanal (allow/deny/alsoAllow).
• channels.msteams.teams.<teamId>.channels.<conversationId>.toolsBySender: Tool-Richtlinienüberschreibungen pro Kanal und Absender ("*"-Wildcard unterstützt).
• toolsBySender-Schlüssel sollten explizite Präfixe verwenden: channel:, id:, e164:, username:, name: (alte Schlüssel ohne Präfix werden weiterhin nur id: zugeordnet).
• channels.msteams.actions.memberInfo: die Graph-gestützte Mitgliedsinformationsaktion aktivieren oder deaktivieren (Standard: aktiviert, wenn Graph-Anmeldedaten verfügbar sind).
• channels.msteams.authType: Authentifizierungstyp - "secret" (Standard) oder "federated".
• channels.msteams.certificatePath: Pfad zur PEM-Zertifikatsdatei (föderierte Authentifizierung + Zertifikatsauthentifizierung).
• channels.msteams.certificateThumbprint: Zertifikat-Fingerabdruck (optional, für die Authentifizierung nicht erforderlich).
• channels.msteams.useManagedIdentity: Managed-Identity-Authentifizierung aktivieren (föderierter Modus).
• channels.msteams.managedIdentityClientId: Client-ID für benutzerseitig zugewiesene Managed Identity.
• channels.msteams.sharePointSiteId: SharePoint-Site-ID für Datei-Uploads in Gruppenchats/Kanälen (siehe Dateien in Gruppenchats senden).

​

Routing und Sitzungen

• Sitzungsschlüssel folgen dem Standardformat für Agenten (siehe /concepts/session):
  • Direktnachrichten teilen sich die Hauptsitzung (agent:<agentId>:<mainKey>).
  • Kanal-/Gruppennachrichten verwenden die Konversations-ID:
    • agent:<agentId>:msteams:channel:<conversationId>
    • agent:<agentId>:msteams:group:<conversationId>

​

Antwortstil: Threads im Vergleich zu Beiträgen

• thread in einem Kanal im Threads-Stil → Antworten erscheinen unpassend verschachtelt
• top-level in einem Kanal im Beiträge-Stil → Antworten erscheinen als separate Top-Level-Beiträge statt innerhalb des Threads

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

​

Auflösungsreihenfolge

1. Pro Kanal — channels.msteams.teams.<teamId>.channels.<conversationId>.replyStyle
2. Pro Team — channels.msteams.teams.<teamId>.replyStyle
3. Global — channels.msteams.replyStyle
4. Impliziter Standard — abgeleitet von requireMention:
   • requireMention: true → thread
   • requireMention: false → top-level

​

Beibehaltung des Thread-Kontexts

​

Anhänge und Bilder

• DMs: Bilder und Dateianhänge funktionieren über Teams-Bot-Datei-APIs.
• Kanäle/Gruppen: Anhänge liegen in M365-Speicher (SharePoint/OneDrive). Die Webhook-Nutzlast enthält nur einen HTML-Stub, nicht die eigentlichen Dateibytes. Graph API-Berechtigungen sind erforderlich, um Kanalanhänge herunterzuladen.
• Für explizite datei-zuerst-Sendungen verwenden Sie action=upload-file mit media / filePath / path; die optionale message wird zum begleitenden Text/Kommentar, und filename überschreibt den hochgeladenen Namen.

​

Dateien in Gruppenchats senden

​

Warum Gruppenchats SharePoint benötigen

​

Einrichtung

1. Graph API-Berechtigungen hinzufügen in Entra ID (Azure AD) → App-Registrierung:
   • Sites.ReadWrite.All (Anwendung) - Dateien nach SharePoint hochladen
   • Chat.Read.All (Anwendung) - optional, aktiviert Freigabelinks pro Benutzer
2. Administratorzustimmung für den Mandanten erteilen.
3. Ihre SharePoint-Site-ID abrufen:
   # 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. OpenClaw konfigurieren:
   {
     channels: {
       msteams: {
         // ... other config ...
         sharePointSiteId: "contoso.sharepoint.com,guid1,guid2",
       },
     },
   }
   

​

Freigabeverhalten

​

Fallback-Verhalten

​

Speicherort von Dateien

​

Umfragen (Adaptive Cards)

• CLI: openclaw message poll --channel msteams --target conversation:<id> ...
• Stimmen werden vom Gateway in ~/.openclaw/msteams-polls.json aufgezeichnet.
• Das Gateway muss online bleiben, um Stimmen aufzuzeichnen.
• Umfragen veröffentlichen noch keine Ergebniszusammenfassungen automatisch (prüfen Sie bei Bedarf die Store-Datei).

​

Präsentationskarten

{
  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!"}]}'

​

Zielformate

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

​

Proaktives Messaging

• Proaktive Nachrichten sind nur möglich, nachdem ein Benutzer interagiert hat, da wir zu diesem Zeitpunkt Unterhaltungsreferenzen speichern.
• Siehe /gateway/configuration für dmPolicy und Allowlist-Gating.

​

Team- und Kanal-IDs (häufiger Stolperstein)

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)

• Team-Schlüssel = Pfadsegment nach /team/ (URL-dekodiert, z. B. 19:Bk4j...@thread.tacv2; ältere Mandanten können @thread.skype anzeigen, was ebenfalls gültig ist)
• Kanal-Schlüssel = Pfadsegment nach /channel/ (URL-dekodiert)
• Ignorieren Sie den Abfrageparameter groupId für OpenClaw-Routing. Es handelt sich um die Microsoft Entra-Gruppen-ID, nicht um die Bot Framework-Unterhaltungs-ID, die in eingehenden Teams-Aktivitäten verwendet wird.

​

Private Kanäle

1. Verwenden Sie Standardkanäle für Bot-Interaktionen
2. Verwenden Sie DMs - Benutzer können dem Bot immer direkt Nachrichten senden
3. Verwenden Sie Graph API für historischen Zugriff (erfordert ChannelMessage.Read.All)

​

Fehlerbehebung

​

Häufige Probleme

• Bilder werden in Kanälen nicht angezeigt: Graph-Berechtigungen oder Admin-Zustimmung fehlen. Installieren Sie die Teams-App neu und beenden/öffnen Sie Teams vollständig neu.
• Keine Antworten im Kanal: Erwähnungen sind standardmäßig erforderlich; setzen Sie channels.msteams.requireMention=false oder konfigurieren Sie dies pro Team/Kanal.
• Versionskonflikt (Teams zeigt weiterhin altes Manifest): Entfernen Sie die App, fügen Sie sie erneut hinzu und beenden Sie Teams vollständig, um es zu aktualisieren.
• 401 Unauthorized vom Webhook: Erwartet bei manuellen Tests ohne Azure JWT - bedeutet, dass der Endpunkt erreichbar ist, die Authentifizierung aber fehlgeschlagen ist. Verwenden Sie Azure Web Chat, um korrekt zu testen.

​

Fehler beim Manifest-Upload

• “Icon file cannot be empty”: Das Manifest verweist auf Icon-Dateien mit 0 Byte. Erstellen Sie gültige PNG-Icons (32x32 für outline.png, 192x192 für color.png).
• “webApplicationInfo.Id already in use”: Die App ist noch in einem anderen Team/Chat installiert. Suchen und deinstallieren Sie sie zuerst, oder warten Sie 5-10 Minuten auf die Verteilung.
• “Something went wrong” beim Upload: Laden Sie stattdessen über https://admin.teams.microsoft.com hoch, öffnen Sie die Browser-DevTools (F12) → Registerkarte Network, und prüfen Sie den Antworttext auf den tatsächlichen Fehler.
• Sideload schlägt fehl: Versuchen Sie “Upload an app to your org’s app catalog” statt “Upload a custom app” - dadurch werden Sideload-Einschränkungen oft umgangen.

​

RSC-Berechtigungen funktionieren nicht

1. Stellen Sie sicher, dass webApplicationInfo.id exakt mit der App-ID Ihres Bots übereinstimmt
2. Laden Sie die App erneut hoch und installieren Sie sie im Team/Chat neu
3. Prüfen Sie, ob Ihr Organisationsadministrator RSC-Berechtigungen blockiert hat
4. Bestätigen Sie, dass Sie den richtigen Scope verwenden: ChannelMessage.Read.Group für Teams, ChatMessage.Read.Chat für Gruppenchats

​

Referenzen

• Azure Bot erstellen - Einrichtungsleitfaden für Azure Bot
• Teams Developer Portal - Teams-Apps erstellen/verwalten
• Teams-App-Manifestschema
• Kanalnachrichten mit RSC empfangen
• Referenz zu RSC-Berechtigungen
• Teams-Bot-Dateiverarbeitung (Kanal/Gruppe erfordert Graph)
• Proaktives Messaging
• @microsoft/teams.cli - Teams-CLI für Bot-Verwaltung

​

Verwandt

• Kanalübersicht - alle unterstützten Kanäle
• Kopplung - DM-Authentifizierung und Kopplungsablauf
• Gruppen - Verhalten von Gruppenchats und Erwähnungs-Gating
• Kanal-Routing - Sitzungs-Routing für Nachrichten
• Sicherheit - Zugriffsmodell und Härtung