​

Telegram (Bot API)

​

Snabb konfigurering (nybörjare)

1. Skapa en bot med @BotFather (direkt länk). Bekräfta att handtaget är exakt @BotFather, sedan kopiera token.
2. Ange token:
   • Env: TELEGRAM_BOT_TOKEN=...
   • Eller konfig: channels.telegram.botToken: "...".
   • Om båda är satta har konfig företräde (env‑fallback gäller endast standardkontot).
3. Starta gateway.
4. DM‑åtkomst är parkoppling som standard; godkänn parkopplingskoden vid första kontakt.

{
  channels: {
    telegram: {
      enabled: true,
      botToken: "123:abc",
      dmPolicy: "pairing",
    },
  },
}

​

Vad det är

• En Telegram Bot API‑kanal som ägs av Gateway.
• Deterministisk routning: svar går tillbaka till Telegram; modellen väljer aldrig kanaler.
• DM:er delar agentens huvudsession; grupper hålls isolerade (agent:<agentId>:telegram:group:<chatId>).

​

Konfigurering (snabb väg)

​

1. Skapa en bot‑token (BotFather)

1. Öppna Telegram och chatta med @BotFather (direkt länk). Bekräfta att handtaget är exakt @BotFather.
2. Kör /newbot, och följ sedan anvisningarna (namn + användarnamn som slutar på bot).
3. Kopiera token och lagra den säkert.

• /setjoingroups — tillåt/förbjud att lägga till boten i grupper.
• /setprivacy — styr om boten ser alla gruppmeddelanden.

​

2. Konfigurera token (env eller konfig)

{
  channels: {
    telegram: {
      enabled: true,
      botToken: "123:abc",
      dmPolicy: "pairing",
      groups: { "*": { requireMention: true } },
    },
  },
}

3. Starta gatewayn. Telegram startar när en token är löst (config först, env fallback).
4. DM åtkomststandard är att para. Godkänn koden när botten först kontaktas.
5. För grupper: lägg till boten, bestäm sekretess/admin‑beteende (nedan) och sätt sedan channels.telegram.groups för att styra nämningskrav + tillåtelselistor.

​

Token + sekretess + behörigheter (Telegram‑sidan)

​

Token‑skapande (BotFather)

• /newbot skapar boten och returnerar token (håll den hemlig).
• Om en token läcker, återkalla/återskapa den via @BotFather och uppdatera din konfig.

​

Synlighet av gruppmeddelanden (Privacy Mode)

• Inaktivera sekretessläge med /setprivacy eller
• Lägg till boten som admin i gruppen (admin‑botar tar emot alla meddelanden).

​

Gruppbehörigheter (admin‑rättigheter)

​

Hur det fungerar (beteende)

• Inkommande meddelanden normaliseras till det delade kanalomslaget med svarskontext och medieplatshållare.
• Gruppsvar kräver nämning som standard (inbyggd @‑nämning eller agents.list[].groupChat.mentionPatterns / messages.groupChat.mentionPatterns).
• Multi‑agent‑override: sätt mönster per agent på agents.list[].groupChat.mentionPatterns.
• Svar routas alltid tillbaka till samma Telegram‑chatt.
• Long‑polling använder grammY‑runner med sekvensering per chatt; total samtidighet begränsas av agents.defaults.maxConcurrent.
• Telegram Bot API stöder inte läskvitton; det finns inget sendReadReceipts‑alternativ.

​

Utkast‑streaming

• Trådat läge aktiverat för boten i @BotFather (forum‑ämnesläge).
• Endast privata chatttrådar (Telegram inkluderar message_thread_id i inkommande meddelanden).
• channels.telegram.streamMode inte satt till "off" (standard: "partial", "block" aktiverar chunkade utkastuppdateringar).

​

Formatering (Telegram HTML)

• Utgående Telegram‑text använder parse_mode: "HTML" (Telegram’s stödda tagg‑delmängd).
• Markdown‑liknande indata renderas till Telegram‑säker HTML (fet/kursiv/genomstruken/kod/länkar); blockelement plattas till text med radbrytningar/punktlistor.
• Rå HTML från modeller escap:as för att undvika Telegram‑parsningfel.
• Om Telegram avvisar HTML‑payloaden försöker OpenClaw igen med samma meddelande som vanlig text.

​

Kommandon (inbyggda + egna)

{
  channels: {
    telegram: {
      customCommands: [
        { command: "backup", description: "Git backup" },
        { command: "generate", description: "Create an image" },
      ],
    },
  },
}

​

Felsökning vid konfigurering (kommandon)

• setMyCommands failed i loggarna betyder oftast att utgående HTTPS/DNS blockeras till api.telegram.org.
• Om du ser sendMessage eller sendChatAction‑fel, kontrollera IPv6‑routning och DNS.

• Egna kommandon är endast menyval; OpenClaw implementerar dem inte om du inte hanterar dem någon annanstans.
• Some commands can be handled by plugins/skills without being registered in Telegram’s command menu. These still work when typed (they just won’t show up in /commands / the menu).
• Kommandonamn normaliseras (inledande / tas bort, gemener) och måste matcha a-z, 0-9, _ (1–32 tecken).
• Anpassade kommandon kan inte åsidosätta infödda kommandon. Konflikter ignoreras och loggas.
• Om commands.native är inaktiverat registreras endast egna kommandon (eller rensas om inga finns).

​

Device pairing commands (device-pair plugin)

1. /pair generates a setup code (sent as a separate message for easy copy/paste).
2. Paste the setup code in the iOS app to connect.
3. /pair approve approves the latest pending device request.

​

Begränsningar

• Utgående text delas upp till channels.telegram.textChunkLimit (standard 4000).
• Valfri radbrytnings‑chunkning: sätt channels.telegram.chunkMode="newline" för att dela på tomrader (styckegränser) före längd‑chunkning.
• Nedladdning/uppladdning av media begränsas av channels.telegram.mediaMaxMb (standard 5).
• Telegram Bot API begär tid ut efter channels.telegram.timeoutSeconds (standard 500 via grammY). Ställ in lägre för att undvika långa hängningar.
• Grupphistorik sammanhang använder channels.telegram.historyLimit (eller channels.telegram.accounts.*.historyLimit), faller tillbaka till messages.groupChat.historyLimit. Sätt 0 till att inaktivera (standard 50).
• DM historik kan begränsas med channels.telegram.dmHistoryLimit (användarvänder). Åsidosättningar per användare: channels.telegram.dms["<user_id>"].historyLimit.

​

Gruppaktiveringslägen

​

Via konfig (rekommenderas)

{
  channels: {
    telegram: {
      groups: {
        "-1001234567890": { requireMention: false }, // always respond in this group
      },
    },
  },
}

{
  channels: {
    telegram: {
      groups: {
        "*": { requireMention: false }, // all groups, always respond
      },
    },
  },
}

{
  channels: {
    telegram: {
      groups: {
        "*": { requireMention: true }, // or omit groups entirely
      },
    },
  },
}

​

Via kommando (sessionsnivå)

• /activation always – svara på alla meddelanden
• /activation mention – kräv nämningar (standard)

​

Hämta gruppens chatt‑ID

​

Konfigskrivningar

• En grupp uppgraderas till en supergrupp och Telegram avger migrate_to_chat_id (chatt ID ändringar). OpenClaw kan migrera channels.telegram.groups automatiskt.
• Du kör /config set eller /config unset i en Telegram‑chatt (kräver commands.config: true).

{
  channels: { telegram: { configWrites: false } },
}

​

Ämnen (forum‑supergrupper)

• Lägger till :topic:<threadId> till Telegram‑gruppens sessionsnyckel så att varje ämne isoleras.
• Skickar skrivindikatorer och svar med message_thread_id så att svaren stannar i ämnet.
• Allmänt ämne (tråd‑ID 1) är speciellt: meddelandesändningar utelämnar message_thread_id (Telegram avvisar det), men skrivindikatorer inkluderar det fortfarande.
• Exponerar MessageThreadId + IsForum i mallkontext för routning/mallning.
• Ämnesspecifik konfiguration finns under channels.telegram.groups<chatId>.trådar.<threadId> (färdigheter, tillåtna listor, auto-svara, systemmeddelanden, inaktivera).
• Ämneskonfig ärver gruppinställningar (requireMention, tillåtelselistor, skills, prompter, aktiverad) om de inte åsidosätts per ämne.

​

Inline‑knappar

{
  channels: {
    telegram: {
      capabilities: {
        inlineButtons: "allowlist",
      },
    },
  },
}

{
  channels: {
    telegram: {
      accounts: {
        main: {
          capabilities: {
            inlineButtons: "allowlist",
          },
        },
      },
    },
  },
}

• off — inline‑knappar inaktiverade
• dm — endast DM:er (gruppmål blockeras)
• group — endast grupper (DM‑mål blockeras)
• all — DM:er + grupper
• allowlist — DM:er + grupper, men endast avsändare som tillåts av allowFrom/groupAllowFrom (samma regler som kontrollkommandon)

​

Skicka knappar

{
  action: "send",
  channel: "telegram",
  to: "123456789",
  message: "Choose an option:",
  buttons: [
    [
      { text: "Yes", callback_data: "yes" },
      { text: "No", callback_data: "no" },
    ],
    [{ text: "Cancel", callback_data: "cancel" }],
  ],
}

​

Konfigurationsalternativ

• channels.telegram.capabilities: Global standard‑kapabilitetskonfig som tillämpas på alla Telegram‑konton om inget åsidosätter.
• channels.telegram.accounts.<account>.capabilities: Per-account funktioner som åsidosätter de globala standardinställningarna för det specifika kontot.

​

Åtkomstkontroll (DM:er + grupper)

​

DM‑åtkomst

• Standard: channels.telegram.dmPolicy = "pairing". Okända avsändare får en parningskod; meddelanden ignoreras tills de godkänts (koder upphör efter 1 timme).
• Godkänn via:
  • openclaw pairing list telegram
  • openclaw pairing approve telegram <CODE>
• Parkoppling är standard token exchange används för Telegram DMs. Detaljer: Pairing
• channels.telegram.allowFrom accepterar numeriska användar-ID (rekommenderas) eller @username-poster. Det är inte bot användarnamn; använd den mänskliga avsändarens ID. Guiden accepterar @username och löser det till numeriskt ID när det är möjligt.

​

Hitta ditt Telegram‑användar‑ID

1. Starta gateway och DM:a din bot.
2. Kör openclaw logs --follow och leta efter from.id.

1. DM:a din bot.
2. Hämta uppdateringar med din bot‑token och läs message.from.id:
   curl "https://api.telegram.org/bot<bot_token>/getUpdates"
   

• DM:a @userinfobot eller @getidsbot och använd det returnerade användar‑ID:t.

​

Gruppåtkomst

• Ingen groups‑konfig = alla grupper tillåtna
• Med groups‑konfig = endast listade grupper eller "*" tillåts
• Exempel: "groups": { "-1001234567890": {}, "*": {} } tillåter alla grupper

• "open" = alla avsändare i tillåtna grupper kan skriva
• "allowlist" = endast avsändare i channels.telegram.groupAllowFrom kan skriva
• "disabled" = inga gruppmeddelanden accepteras alls Standard är groupPolicy: "allowlist" (blockerat om du inte lägger till groupAllowFrom).

{
  channels: {
    telegram: {
      groups: {
        "-1001234567890": {
          groupPolicy: "open",
          requireMention: false,
        },
      },
    },
  },
}

​

Long‑polling vs webhook

• Standard: long‑polling (ingen publik URL krävs).
• Webhook‑läge: sätt channels.telegram.webhookUrl och channels.telegram.webhookSecret (valfritt channels.telegram.webhookPath).
  • Den lokala lyssnaren binder till 0.0.0.0:8787 och serverar POST /telegram-webhook som standard.
  • Om din publika URL är annorlunda, använd en reverse proxy och peka channels.telegram.webhookUrl mot den publika ändpunkten.

​

Svarstrådning

• [[reply_to_current]] — svara på det utlösande meddelandet.
• [[reply_to:<id>]] — svara på ett specifikt meddelande‑ID.

• first (standard), all, off.

​

Ljudmeddelanden (röst vs fil)

• [[audio_as_voice]] — skicka ljud som röstanteckning i stället för fil.

{
  action: "send",
  channel: "telegram",
  to: "123456789",
  media: "https://example.com/voice.ogg",
  asVoice: true,
}

​

Video messages (video vs video note)

{
  action: "send",
  channel: "telegram",
  to: "123456789",
  media: "https://example.com/video.mp4",
  asVideoNote: true,
}

​

Klistermärken

​

Ta emot klistermärken

• Statiska klistermärken (WEBP): Nedladdade och bearbetade genom syn. Klistermärket visas som en <media:sticker> platshållare i meddelandets innehåll.
• Animerade klistermärken (TGS): Hoppas över (Lottie‑format stöds inte för bearbetning).
• Videoklistermärken (WEBM): Hoppas över (videoformat stöds inte för bearbetning).

• Sticker — objekt med:
  • emoji — emoji kopplad till klistermärket
  • setName — namn på klistermärkesetet
  • fileId — Telegram‑fil‑ID (skicka samma klistermärke tillbaka)
  • fileUniqueId — stabilt ID för cache‑uppslag
  • cachedDescription — cachad visionsbeskrivning när tillgänglig

​

Klistermärkes‑cache

1. Första träffen: Klistermärkesbilden skickas till AI för synanalys. AI genererar en beskrivning (t.ex., “En tecknad katt viftar entusiastiskt”).
2. Cache‑lagring: Beskrivningen sparas tillsammans med klistermärkesfil‑ID, emoji och set‑namn.
3. Efterföljande möten: När samma dekal ses igen används den cachade beskrivningen direkt. Bilden skickas inte till AI.

{
  "fileId": "CAACAgIAAxkBAAI...",
  "fileUniqueId": "AgADBAADb6cxG2Y",
  "emoji": "👋",
  "setName": "CoolCats",
  "description": "A cartoon cat waving enthusiastically",
  "cachedAt": "2026-01-15T10:30:00.000Z"
}

• Minskar API‑kostnader genom att undvika upprepade visionsanrop för samma klistermärke
• Snabbare svarstider för cachade klistermärken (ingen visionsfördröjning)
• Möjliggör klistermärkesökning baserad på cachade beskrivningar

​

Skicka klistermärken

{
  channels: {
    telegram: {
      actions: {
        sticker: true,
      },
    },
  },
}

{
  action: "sticker",
  channel: "telegram",
  to: "123456789",
  fileId: "CAACAgIAAxkBAAI...",
}

• fileId (obligatoriskt) — Telegram fil-ID för klistermärket. Få detta från Sticker.fileId när du tar emot en klistermärke, eller från ett sticker-search-resultat.
• replyTo (valfri) — meddelande‑ID att svara på.
• threadId (valfri) — meddelandetråd‑ID för forumämnen.

{
  action: "sticker-search",
  channel: "telegram",
  query: "cat waving",
  limit: 5,
}

{
  ok: true,
  count: 2,
  stickers: [
    {
      fileId: "CAACAgIAAxkBAAI...",
      emoji: "👋",
      description: "A cartoon cat waving enthusiastically",
      setName: "CoolCats",
    },
  ],
}

{
  action: "sticker",
  channel: "telegram",
  to: "-1001234567890",
  fileId: "CAACAgIAAxkBAAI...",
  replyTo: 42,
  threadId: 123,
}

​

Streaming (utkast)

• Privata chattar med ämnen aktiverade (forum‑ämnesläge för boten).
• Inkommande meddelanden måste inkludera message_thread_id (privat ämnestråd).
• Streaming ignoreras för grupper/supergrupper/kanaler.

• channels.telegram.streamMode: "off" | "partial" | "block" (standard: partial)
  • partial: uppdatera utkastbubblan med den senaste strömningstexten.
  • block: uppdatera utkastbubblan i större block (chunkat).
  • off: inaktivera utkast‑streaming.
• Valfritt (endast för streamMode: "block"):
  • channels.telegram.draftChunk: { minChars?, maxChars?, breakPreference? }
    • standardvärden: minChars: 200, maxChars: 800, breakPreference: "paragraph" (begränsat till channels.telegram.textChunkLimit).

• /reasoning stream strömmar resonemang till utkastbubblan medan svaret genereras, och skickar sedan det slutliga svaret utan resonemang.
• Om channels.telegram.streamMode är off, är resonerande ström inaktiverad. Mer sammanhang: Streaming + chunking.

​

Policy för omförsök

​

Agentverktyg (meddelanden + reaktioner)

• Verktyg: telegram med åtgärden sendMessage (to, content, valfritt mediaUrl, replyToMessageId, messageThreadId).
• Verktyg: telegram med åtgärden react (chatId, messageId, emoji).
• Verktyg: telegram med åtgärden deleteMessage (chatId, messageId).
• Semantik för borttagning av reaktioner: se /tools/reactions.
• Verktygsgating: channels.telegram.actions.reactions, channels.telegram.actions.sendMessage, channels.telegram.actions.deleteMessage (standard: aktiverad) och channels.telegram.actions.sticker (standard: inaktiverad).

​

Reaktionsnotifieringar

1. Tar emot message_reaction‑uppdateringen från Telegram API
2. Konverterar den till en systemhändelse med format: "Telegram reaction added: {emoji} by {user} on msg {id}"
3. Köar systemhändelsen med samma sessionsnyckel som vanliga meddelanden
4. När nästa meddelande anländer i konversationen töms systemhändelserna och förhandsläggs i agentens kontext

• channels.telegram.reactionNotifications: Styr vilka reaktioner som triggar notifieringar
  • "off" — ignorera alla reaktioner
  • "own" — notifiera när användare reagerar på botmeddelanden (best effort; i minnet) (standard)
  • "all" — notifiera för alla reaktioner
• channels.telegram.reactionLevel: Styr agentens reaktionsförmåga
  • "off" — agenten kan inte reagera på meddelanden
  • "ack" — boten skickar bekräftelsereaktioner (👀 under bearbetning) (standard)
  • "minimal" — agenten kan reagera sparsamt (riktlinje: 1 per 5–10 utbyten)
  • "extensive" — agenten kan reagera generöst när lämpligt

{
  channels: {
    telegram: {
      reactionNotifications: "all", // See all reactions
      reactionLevel: "minimal", // Agent can react sparingly
    },
  },
}

• Telegram‑botar måste uttryckligen begära message_reaction i allowed_updates (konfigureras automatiskt av OpenClaw)
• I webhook‑läge inkluderas reaktioner i webhook‑allowed_updates
• I polling‑läge inkluderas reaktioner i getUpdates allowed_updates

​

Leveransmål (CLI/cron)

• Använd ett chatt‑ID (123456789) eller ett användarnamn (@name) som mål.
• Exempel: openclaw message send --channel telegram --target 123456789 --message "hi".

​

Felsökning

• Om du satte channels.telegram.groups.*.requireMention=false måste Telegrams Bot API sekretessläge vara inaktiverat.
  • BotFather: /setprivacy → Disable (ta sedan bort + lägg till boten i gruppen igen)
• openclaw channels status visar en varning när konfig förväntar sig onämnda gruppmeddelanden.
• openclaw channels status --probe kan dessutom kontrollera medlemskap för explicita numeriska grupp‑ID:n (den kan inte granska wildcard‑regler som "*").
• Snabbtest: /activation always (endast session; använd konfig för beständighet)

• Om channels.telegram.groups är satt måste gruppen vara listad eller använda "*"
• Kontrollera sekretessinställningar i @BotFather → ”Group Privacy” ska vara OFF
• Verifiera att boten faktiskt är medlem (inte bara admin utan läsåtkomst)
• Kontrollera gateway‑loggar: openclaw logs --follow (leta efter ”skipping group message”)

• Kommandot /activation uppdaterar sessionsstatus men sparar inte i konfig
• För beständigt beteende, lägg till gruppen i channels.telegram.groups med requireMention: false

• Säkerställ att ditt Telegram‑användar‑ID är auktoriserat (via parkoppling eller channels.telegram.allowFrom)
• Kommandon kräver auktorisering även i grupper med groupPolicy: "open"

• Node 22+ är striktare med AbortSignal‑instanser; främmande signaler kan avbryta fetch‑anrop direkt.
• Uppgradera till en OpenClaw‑build som normaliserar abort‑signaler, eller kör gateway på Node 20 tills du kan uppgradera.

• Vissa värdar löser api.telegram.org till IPv6 först. Om din server inte har fungerande IPv6-egress, kan grammy fastna på IPv6-förfrågningar.
• Åtgärda genom att aktivera IPv6‑utgående trafik eller tvinga IPv4‑upplösning för api.telegram.org (t.ex. lägg till en /etc/hosts‑post med IPv4‑A‑posten, eller föredra IPv4 i OS:ets DNS‑stack), och starta sedan om gateway.
• Snabbkontroll: dig +short api.telegram.org A och dig +short api.telegram.org AAAA för att bekräfta vad DNS returnerar.

​

Konfigurationsreferens (Telegram)

• channels.telegram.enabled: aktivera/inaktivera kanalstart.
• channels.telegram.botToken: bot‑token (BotFather).
• channels.telegram.tokenFile: läs token från filsökväg.
• channels.telegram.dmPolicy: pairing | allowlist | open | disabled (standard: parkoppling).
• channels.telegram.allowFrom: DM allowlist (ids/användarnamn). open kräver "*".
• channels.telegram.groupPolicy: open | allowlist | disabled (standard: tillåtelselista).
• channels.telegram.groupAllowFrom: grupp‑avsändar‑tillåtelselista (ID:n/användarnamn).
• channels.telegram.groups: per‑grupp‑standarder + tillåtelselista (använd "*" för globala standarder).
  • channels.telegram.groups.<id>.groupPolicy: åsidosätt per grupp för groupPolicy (open <unk> allowlist <unk> disabled).
  • channels.telegram.groups.<id>.requireMention: nämna gating default.
  • channels.telegram.groups.<id>.skills: färdighetsfilter (utelämna = alla Skills, tom = inga).
  • channels.telegram.groups.<id>.allowFrom: Avsändare per grupp tillåten lista åsidosätt.
  • channels.telegram.groups.<id>.systemPrompt: extra systemprompt för gruppen.
  • channels.telegram.groups.<id>.enabled: inaktivera gruppen när false.
  • channels.telegram.groups.<id>.trådar.<threadId>.*: åsidosättningar per ämne (samma fält som grupp).
  • channels.telegram.groups.<id>.trådar.<threadId>.groupPolicy: åsidosätt per ämne för groupPolicy (open <unk> allowlist <unk> disabled).
  • channels.telegram.groups.<id>.trådar.<threadId>.requireMention: per ämne nämner gating override.
• channels.telegram.capabilities.inlineButtons: off | dm | group | all | allowlist (standard: tillåtelselista).
• channels.telegram.accounts.<account>.capabilities.inlineButtons: åsidosätter per konto.
• channels.telegram.replyToMode: off | first | all (standard: first).
• channels.telegram.textChunkLimit: utgående chunk‑storlek (tecken).
• channels.telegram.chunkMode: length (standard) eller newline för att dela på tomrader (styckegränser) före längd‑chunkning.
• channels.telegram.linkPreview: växla länkförhandsvisningar för utgående meddelanden (standard: true).
• channels.telegram.streamMode: off | partial | block (utkast‑streaming).
• channels.telegram.mediaMaxMb: gräns för inkommande/utgående media (MB).
• channels.telegram.retry: policy för omförsök för utgående Telegram API‑anrop (försök, minDelayMs, maxDelayMs, jitter).
• channels.telegram.network.autoSelectFamily: åsidosätta Noden autoSelectFamily (true=enable, false=disable). Standard är inaktiverat på Node 22 för att undvika tidsgräns för Happy Eyeball.
• channels.telegram.proxy: proxy‑URL för Bot API‑anrop (SOCKS/HTTP).
• channels.telegram.webhookUrl: aktivera webhook‑läge (kräver channels.telegram.webhookSecret).
• channels.telegram.webhookSecret: webhook‑hemlighet (krävs när webhookUrl är satt).
• channels.telegram.webhookPath: lokal webhook‑sökväg (standard /telegram-webhook).
• channels.telegram.actions.reactions: gate Telegram‑verktygsreaktioner.
• channels.telegram.actions.sendMessage: gate Telegram‑verktygets meddelandesändningar.
• channels.telegram.actions.deleteMessage: gate Telegram‑verktygets borttagning av meddelanden.
• channels.telegram.actions.sticker: gate Telegram‑klistermärkesåtgärder — skicka och sök (standard: false).
• channels.telegram.reactionNotifications: off | own | all — styr vilka reaktioner som triggar systemhändelser (standard: own när ej satt).
• channels.telegram.reactionLevel: off | ack | minimal | extensive — styr agentens reaktionsförmåga (standard: minimal när ej satt).

• agents.list[].groupChat.mentionPatterns (nämningsmönster).
• messages.groupChat.mentionPatterns (global fallback).
• commands.native (standard är "auto" → on för Telegram/Discord, off för Slack), commands.text, commands.useAccessGroups (kommandobeteende). Åsidosätt med channels.telegram.commands.native.
• messages.responsePrefix, messages.ackReaction, messages.ackReactionScope, messages.removeAckAfterReply.