​

Konfiguracja 🔧

• ograniczyć, kto może wyzwalać bota (channels.whatsapp.allowFrom, channels.telegram.allowFrom itd.)
• kontrolować listy dozwolonych grup i zachowanie wzmiankowania (channels.whatsapp.groups, channels.telegram.groups, channels.discord.guilds, agents.list[].groupChat)
• dostosować prefiksy wiadomości (messages)
• ustawić obszar roboczy agenta (agents.defaults.workspace lub agents.list[].workspace)
• dostroić domyślne ustawienia wbudowanego agenta (agents.defaults) oraz zachowanie sesji (session)
• ustawić tożsamość per‑agent (agents.list[].identity)

Nowy w konfiguracji? Zobacz przewodnik Configuration Examples, aby zapoznać się z kompletnymi przykładami wraz ze szczegółowymi wyjaśnieniami!

​

Ścisła weryfikacja konfiguracji

• Gateway nie startuje.
• Dozwolone są wyłącznie polecenia diagnostyczne (na przykład: openclaw doctor, openclaw logs, openclaw health, openclaw status, openclaw service, openclaw help).
• Uruchom openclaw doctor, aby zobaczyć dokładne problemy.
• Uruchom openclaw doctor --fix (lub --yes), aby zastosować migracje/naprawy.

​

Schemat + podpowiedzi UI

​

Zastosuj + restart (RPC)

• raw (string) — ładunek JSON5 dla całej konfiguracji
• baseHash (opcjonalne) — hash konfiguracji z config.get (wymagane, gdy konfiguracja już istnieje)
• sessionKey (opcjonalne) — klucz ostatniej aktywnej sesji do pingu wybudzającego
• note (opcjonalne) — notatka do dołączenia do znacznika restartu
• restartDelayMs (opcjonalne) — opóźnienie przed restartem (domyślnie 2000)

openclaw gateway call config.get --params '{}' # capture payload.hash
openclaw gateway call config.apply --params '{
  "raw": "{\\n  agents: { defaults: { workspace: \\"~/.openclaw/workspace\\" } }\\n}\\n",
  "baseHash": "<hash-from-config.get>",
  "sessionKey": "agent:main:whatsapp:dm:+15555550123",
  "restartDelayMs": 1000
}'

​

Aktualizacje częściowe (RPC)

• obiekty scalają rekursywnie
• null usuwa klucz
• tablice są zastępowane
  Podobnie jak config.apply, polecenie waliduje, zapisuje konfigurację, zapisuje znacznik restartu i planuje restart Gateway (z opcjonalnym wybudzeniem, gdy podano sessionKey).

• raw (string) — ładunek JSON5 zawierający wyłącznie klucze do zmiany
• baseHash (wymagane) — hash konfiguracji z config.get
• sessionKey (opcjonalne) — klucz ostatniej aktywnej sesji do pingu wybudzającego
• note (opcjonalne) — notatka do dołączenia do znacznika restartu
• restartDelayMs (opcjonalne) — opóźnienie przed restartem (domyślnie 2000)

openclaw gateway call config.get --params '{}' # capture payload.hash
openclaw gateway call config.patch --params '{
  "raw": "{\\n  channels: { telegram: { groups: { \\"*\\": { requireMention: false } } } }\\n}\\n",
  "baseHash": "<hash-from-config.get>",
  "sessionKey": "agent:main:whatsapp:dm:+15555550123",
  "restartDelayMs": 1000
}'

​

Minimalna konfiguracja (zalecany punkt startowy)

{
  agents: { defaults: { workspace: "~/.openclaw/workspace" } },
  channels: { whatsapp: { allowFrom: ["+15555550123"] } },
}

scripts/sandbox-setup.sh

​

Tryb self‑chat (zalecany do kontroli grup)

{
  agents: {
    defaults: { workspace: "~/.openclaw/workspace" },
    list: [
      {
        id: "main",
        groupChat: { mentionPatterns: ["@openclaw", "reisponde"] },
      },
    ],
  },
  channels: {
    whatsapp: {
      // Allowlist is DMs only; including your own number enables self-chat mode.
      allowFrom: ["+15555550123"],
      groups: { "*": { requireMention: true } },
    },
  },
}

​

Dołączanie konfiguracji ($include)

• organizowania dużych konfiguracji (np. definicji agentów per klient)
• współdzielenia wspólnych ustawień między środowiskami
• oddzielania wrażliwych konfiguracji

​

Podstawowe użycie

// ~/.openclaw/openclaw.json
{
  gateway: { port: 18789 },

  // Include a single file (replaces the key's value)
  agents: { $include: "./agents.json5" },

  // Include multiple files (deep-merged in order)
  broadcast: {
    $include: ["./clients/mueller.json5", "./clients/schmidt.json5"],
  },
}

// ~/.openclaw/agents.json5
{
  defaults: { sandbox: { mode: "all", scope: "session" } },
  list: [{ id: "main", workspace: "~/.openclaw/workspace" }],
}

​

Scal zachowanie

• Pojedynczy plik: zastępuje obiekt zawierający $include
• Tablica plików: głęboko scala pliki w kolejności (późniejsze nadpisują wcześniejsze)
• Z kluczami sąsiednimi: klucze sąsiednie są scalane po include (nadpisują wartości dołączone)
• Klucze sąsiednie + tablice/prymitywy: nieobsługiwane (dołączona zawartość musi być obiektem)

// Sibling keys override included values
{
  $include: "./base.json5", // { a: 1, b: 2 }
  b: 99, // Result: { a: 1, b: 99 }
}

​

Zagnieżdżone include

// clients/mueller.json5
{
  agents: { $include: "./mueller/agents.json5" },
  broadcast: { $include: "./mueller/broadcast.json5" },
}

​

Rozwiązywanie ścieżek

• Ścieżki względne: rozwiązywane względem pliku dołączającego
• Ścieżki bezwzględne: używane bez zmian
• Katalogi nadrzędne: odwołania ../ działają zgodnie z oczekiwaniami

{ "$include": "./sub/config.json5" }      // relative
{ "$include": "/etc/openclaw/base.json5" } // absolute
{ "$include": "../shared/common.json5" }   // parent dir

​

Obsługa błędów

• Brak pliku: czytelny błąd z rozwiązaną ścieżką
• Błąd parsowania: wskazuje, który dołączony plik się nie powiódł
• Cykliczne include: wykrywane i raportowane wraz z łańcuchem include

​

Przykład: konfiguracja prawna dla wielu klientów

// ~/.openclaw/openclaw.json
{
  gateway: { port: 18789, auth: { token: "secret" } },

  // Common agent defaults
  agents: {
    defaults: {
      sandbox: { mode: "all", scope: "session" },
    },
    // Merge agent lists from all clients
    list: { $include: ["./clients/mueller/agents.json5", "./clients/schmidt/agents.json5"] },
  },

  // Merge broadcast configs
  broadcast: {
    $include: ["./clients/mueller/broadcast.json5", "./clients/schmidt/broadcast.json5"],
  },

  channels: { whatsapp: { groupPolicy: "allowlist" } },
}

// ~/.openclaw/clients/mueller/agents.json5
[
  { id: "mueller-transcribe", workspace: "~/clients/mueller/transcribe" },
  { id: "mueller-docs", workspace: "~/clients/mueller/docs" },
]

// ~/.openclaw/clients/mueller/broadcast.json5
{
  "[email protected]": ["mueller-transcribe", "mueller-docs"],
}

​

Wspólne opcje

​

Env vars + .env

• .env z bieżącego katalogu roboczego (jeśli istnieje)
• globalny fallback .env z ~/.openclaw/.env (czyli $OPENCLAW_STATE_DIR/.env)

{
  env: {
    OPENROUTER_API_KEY: "sk-or-...",
    vars: {
      GROQ_API_KEY: "gsk-...",
    },
  },
}

​

env.shellEnv (opcjonalne)

{
  env: {
    shellEnv: {
      enabled: true,
      timeoutMs: 15000,
    },
  },
}

• OPENCLAW_LOAD_SHELL_ENV=1
• OPENCLAW_SHELL_ENV_TIMEOUT_MS=15000

​

Podstawienie Env var w konfiguracji

{
  models: {
    providers: {
      "vercel-gateway": {
        apiKey: "${VERCEL_GATEWAY_API_KEY}",
      },
    },
  },
  gateway: {
    auth: {
      token: "${OPENCLAW_GATEWAY_TOKEN}",
    },
  },
}

• Dopasowywane są tylko nazwy zmiennych zapisane wielkimi literami: [A-Z_][A-Z0-9_]*
• Brakujące lub puste zmienne powodują błąd podczas ładowania konfiguracji
• Użyj $${VAR}, aby wypisać dosłowny ${VAR}
• Działa z $include (dołączane pliki również podlegają podstawianiu)

{
  models: {
    providers: {
      custom: {
        baseUrl: "${CUSTOM_API_BASE}/v1", // → "https://api.example.com/v1"
      },
    },
  },
}

​

Przechowywanie uwierzytelniania (OAuth + klucze API)

• <agentDir>/auth-profiles.json (domyślnie: ~/.openclaw/agents/<agentId>/agent/auth-profiles.json)

• ~/.openclaw/credentials/oauth.json (lub $OPENCLAW_STATE_DIR/credentials/oauth.json)

• <agentDir>/auth.json (zarządzane automatycznie; nie edytuj ręcznie)

• ~/.openclaw/agent/* (migrowany przez openclaw doctor do ~/.openclaw/agents/<defaultAgentId>/agent/*)

• Katalog OAuth (tylko import legacy): OPENCLAW_OAUTH_DIR
• Katalog agenta (nadpisanie domyślnego katalogu głównego agenta): OPENCLAW_AGENT_DIR (zalecane), PI_CODING_AGENT_DIR (legacy)

​

auth

{
  auth: {
    profiles: {
      "anthropic:[email protected]": { provider: "anthropic", mode: "oauth", email: "[email protected]" },
      "anthropic:work": { provider: "anthropic", mode: "api_key" },
    },
    order: {
      anthropic: ["anthropic:[email protected]", "anthropic:work"],
    },
  },
}

​

agents.list[].identity

• messages.ackReaction z identity.emoji aktywnego agenta (fallback 👀)
• agents.list[].groupChat.mentionPatterns z identity.name/identity.emoji agenta (dzięki czemu „@Samantha” działa w grupach na Telegram/Slack/Discord/Google Chat/iMessage/WhatsApp)
• identity.avatar akceptuje ścieżkę obrazu względem obszaru roboczego lub zdalny URL/data URL. Pliki lokalne muszą znajdować się w obszarze roboczym agenta.

• Ścieżkę względem obszaru roboczego (musi pozostać w obrębie obszaru roboczego agenta)
• URL http(s)
• URI data:

{
  agents: {
    list: [
      {
        id: "main",
        identity: {
          name: "Samantha",
          theme: "helpful sloth",
          emoji: "🦥",
          avatar: "avatars/samantha.png",
        },
      },
    ],
  },
}

​

wizard

{
  wizard: {
    lastRunAt: "2026-01-01T00:00:00.000Z",
    lastRunVersion: "2026.1.4",
    lastRunCommit: "abc1234",
    lastRunCommand: "configure",
    lastRunMode: "local",
  },
}

​

logging

• Domyślny plik logów: /tmp/openclaw/openclaw-YYYY-MM-DD.log
• Jeśli potrzebujesz stabilnej ścieżki, ustaw logging.file na /tmp/openclaw/openclaw.log.
• Wyjście konsoli można stroić osobno poprzez:
  • logging.consoleLevel (domyślnie info, podnosi do debug gdy --verbose)
  • logging.consoleStyle (pretty | compact | json)
• Podsumowania narzędzi mogą być redagowane, aby uniknąć wycieku sekretów:
  • logging.redactSensitive (off | tools, domyślnie: tools)
  • logging.redactPatterns (tablica regexów; nadpisuje domyślne)

{
  logging: {
    level: "info",
    file: "/tmp/openclaw/openclaw.log",
    consoleLevel: "info",
    consoleStyle: "pretty",
    redactSensitive: "tools",
    redactPatterns: [
      // Example: override defaults with your own rules.
      "\\bTOKEN\\b\\s*[=:]\\s*([\"']?)([^\\s\"']+)\\1",
      "/\\bsk-[A-Za-z0-9_-]{8,}\\b/gi",
    ],
  },
}

​

channels.whatsapp.dmPolicy

• "pairing" (domyślnie): nieznani nadawcy otrzymują kod parowania; właściciel musi zatwierdzić
• "allowlist": zezwalaj tylko nadawcom z channels.whatsapp.allowFrom (lub sparowanej listy dozwolonych)
• "open": zezwalaj na wszystkie przychodzące DM‑y (wymaga, aby channels.whatsapp.allowFrom zawierało "*")
• "disabled": ignoruj wszystkie przychodzące DM‑y

• openclaw pairing list whatsapp
• openclaw pairing approve whatsapp <code>

​

channels.whatsapp.allowFrom

{
  channels: {
    whatsapp: {
      dmPolicy: "pairing", // pairing | allowlist | open | disabled
      allowFrom: ["+15555550123", "+447700900123"],
      textChunkLimit: 4000, // optional outbound chunk size (chars)
      chunkMode: "length", // optional chunking mode (length | newline)
      mediaMaxMb: 50, // optional inbound media cap (MB)
    },
  },
}

​

channels.whatsapp.sendReadReceipts

{
  channels: {
    whatsapp: { sendReadReceipts: false },
  },
}

​

channels.whatsapp.accounts (wiele kont)

{
  channels: {
    whatsapp: {
      accounts: {
        default: {}, // optional; keeps the default id stable
        personal: {},
        biz: {
          // Optional override. Default: ~/.openclaw/credentials/whatsapp/biz
          // authDir: "~/.openclaw/credentials/whatsapp/biz",
        },
      },
    },
  },
}

• Polecenia wychodzące domyślnie używają konta default, jeśli istnieje; w przeciwnym razie pierwszego skonfigurowanego identyfikatora konta (sortowane).
• Starszy katalog uwierzytelniania Baileys dla pojedynczego konta jest migrowany przez openclaw doctor do whatsapp/default.

​

channels.telegram.accounts / channels.discord.accounts / channels.googlechat.accounts / channels.slack.accounts / channels.mattermost.accounts / channels.signal.accounts / channels.imessage.accounts

{
  kanałów: {
    telegram: {
      kont: {
        domyślnie: {
          nazwa: "Primary bot",
          botToken: "123456:ABC... ,
        }, Alerty
        : {
          nazwa: "Alerts bot",
          botToken: "987654:XYZ. .",
        },
      },
    },
  },
}

• default jest używany, gdy accountId jest pomijany (CLI + routing).
• Tokeny Env dotyczą tylko domyślnego konta.
• Podstawowe ustawienia kanału (polityka grupowa, wzmianka o bramkach itp.) stosuje się do wszystkich kont, chyba że nadpisano na konto.
• Użyj bindings[].match.accountId aby przekierować każde konto do innego agenta.defaults.

​

Bramowanie czatu grupowego (agents.list[].Czat + messages.groupChat)

• Wzmianki o metadanych: Natywna platforma @-wzmianki (np. WhatsApp tap-to-mention). Ignorowane w trybie własnego czatu WhatsApp (patrz channels.whatsapp.allowFrom).
• Wzory tekstu: Wzory Regex zdefiniowane w agents.list[].groupChat.mentionPatterns. Zawsze sprawdzane niezależnie od trybu samodzielnego czatu.
• Bramowanie wzmiankowe jest wymuszone tylko wtedy, gdy wykrycie wzmianki jest możliwe (wzmianki wzmiankowe lub co najmniej jeden “wzmianka”).

{
  wiadomości: {
    groupChat: { historyLimit: 50 },
  },
  agentów: {
    list: [{ id: "main", groupChat: { mentionPatterns: ["@openclaw", "openclaw"] } }],
  },
}

​

Limity historii DM

{
  kanałów: {
    telegram: {
      dmHistoryLimit: 30, // limit sesji DM do 30 użytkowników zamienia
      dms: {
        "123456789": { historyLimit: 50 }, // nadpisanie przez użytkownika (ID użytkownika)
      },
    },
  },
}

1. Nadpisanie per-DM: kanały.<provider>.dms[userId].historyLimit
2. Domyślny dostawca: kanały.<provider>.dmHistoryLimit
3. Brak limitu (cała historia zachowana)

{
  agents: {
    list: [
      { id: "work", groupChat: { mentionPatterns: ["@workbot", "\\+15555550123"] } },
      { id: "personal", groupChat: { mentionPatterns: ["@homebot", "\\+15555550999"] } },
    ],
  },
}

{
  kanałów: {
    whatsapp: {
      // Dołącz swój własny numer, aby włączyć tryb samodzielnego czatu (ignoruj natywne @-wzmianki).
      allowFod: ["+15555550123"],
      grupy: { "*": { requireMention: true } },
    },
  },
  agentów: {
    lista: [
      {
        id: "main",
        groupChat: {
          // Tylko te wzorce tekstowe wyzwalają odpowiedzi
          wzmianki: ["reisponde", "@openclaw"],
        },
      },
    ],
  },
}

​

Zasady grupowe (na kanał)

{
  kanałów: {
    whatsapp: {
      groupPolicy: "allowlist",
      groupAllowFod: ["+15551234567"],
    },
    telegram: {
      groupPolicy: "allowlist",
      groupAllowFrom: ["tg:123456789", "@alice"],
    },
    signal: {
      groupPolicy: "allowlist",
      groupAllowFod: ["+15551234567"],
    },
    imesage: {
      groupPolicy: "allowlist",
      groupAllowFod: ["chat_id:123"],
    },
    msteams: {
      groupPolicy: "allowlist",
      groupAllowFrom: ["user@org. om"],
    },
    discord: {
      groupPolicy: "allowlist",
      guilds: {
        GUILD_ID: {
          kanałów: { help: { allow: true } },
        },
      },
    },
    slack: {
      groupPolicy: "allowlist",
      kanały: { "#general": { allow: true } },
    },
  },
}

• "open": groups bypass allowlists; ention-gating nadal występuje.
• `“disabled”: blokuj wszystkie wiadomości grupy/pokoju.
• "allowlist": zezwól tylko na grupy / pokoje, które pasują do skonfigurowanej listy dozwolonych.
• channels.defaults.groupPolicy ustawia wartość domyślną, gdy groupPolicy dostawcy jest nieustawiona.
• WhatsApp/Telegram/Signal/iMessage/Microsoft Teams używają groupAllowFrom (fallback: explicit allowFrom).
• Discord/Slack używaj list kanałów (channels.discord.guilds.*.channels, channels.slack.channels).
• DM z grupy (Discord/Slack) są nadal kontrolowane przez dm.groupEnabled + dm.groupChannels.
• Domyślnie jest groupPolicy: "allowlist" (chyba że nadpisano przez channels.defaults.groupPolicy); jeśli nie skonfigurowano dozwolonej listy, wiadomości grupowe są zablokowane.

​

Przekierowywanie wielu agentów (agents.list + bindings)

• agents.list[]: nadpisanie per-agenta.
  • id: stabilny identyfikator agenta (wymagany).
  • default: opcjonalne; gdy ustawione są wielokrotności, rejestruje się pierwsze wygrane i ostrzeżenie. Jeśli nic nie jest ustawione, pierwszy wpis na liście jest domyślnym agentem.
  • nazwa: wyświetlana nazwa agenta.
  • obszar roboczy: domyślny ~/.openclaw/workspace-<agentId> (dla main, spada z powrotem do agents.defaults.workspace).
  • agentDir: domyślne ~/.openclaw/agents/<agentId>/agent.
  • model: model domyślny dla agenta, zastępuje agents.defaults.model dla tego agenta.
    • formularz ciągu: "provider/model", zastępuje tylko agents.defaults.model.primary
    • formularz obiektu: { primary, fallbacks } (fallbacks override agents.defaults.model.fallbacks; [] wyłącza globalne upadki dla tego agenta)
  • identity: nazwa agenta / motyw/emoji (używane do wzmianki o wzorcach + brak reakcji).
  • groupChat: na agenta wzmianka o bramce (mentionPatterns).
  • sandbox: konfiguracja piaskownicy dla agenta (zastępuje agents.defaults.sandbox).
    • mode: "off" | "non-main" | "all"
    • workspaceAccess: "none" | "ro" | "rw"
    • zakresu: "session" | "agent" | "shared"
    • workspaceRoot: niestandardowy obszar roboczy sandbox root
    • docker: nadpisywanie przez agenta (np. image, sieć, env, setupCommand, limity; ignorowane gdy scope: "shared")
    • browser: nadpisanie przeglądarki piaskowanej przez agenta (ignorowane, gdy zakres: "shared")
    • prune: nadpisywanie piaskownicy dla agenta (ignorowane gdy zakres: "shared")
  • subagentów: domyślne dla agenta subagenta.
    • allowAgents: allowlist agent id for sessions_spawn from this agent (["*"] = allow any; default: only this agent)
  • tools: ograniczenia narzędzia dla każdego agenta (stosowane przed polityką narzędzia piaskowego).
    • profile: profil narzędzia bazowego (stosowany przed zezwolnieniem/odrzuceniem)
    • allow: tablica dozwolonych nazw narzędzi
    • deny: tablica nazw odrzuconych narzędzi (odmowa wygrana)
• agents.defaults: domyślne współdzielony agent (model, obszar roboczy, sandbox, itp.).
• bindings[]: kieruje przychodzące wiadomości do agentId.
  • match.channel (wymagane)
  • match.accountId (opcjonalne; * = dowolne konto; pominięte = domyślne konto)
  • match.peer (opcjonalne; { kind: direct|group|channel, id })
  • match.guildId / match.teamId (opcjonalne; specyficzne dla kanału)

1. match.peer
2. match.guildId
3. match.teamId
4. match.accountId (akt, brak peer/guild/team)
5. match.accountId: "*" (cały kanał, brak peer/guild/team)
6. domyślny agent (agents.list[].domyślny, w przeciwnym razie pierwszy wpis na liście, w przeciwnym razie "main")

​

Profile dostępu per agent (multi‑agent)

• Pełny dostęp (osobisty agent)
• Tylko do odczytu narzędzia + obszar roboczy
• Brak dostępu do systemu plików (tylko narzędzia do wiadomości/sesji)

{
  agents: {
    list: [
      {
        id: "personal",
        workspace: "~/.openclaw/workspace-personal",
        sandbox: { mode: "off" },
      },
    ],
  },
}

{
  agents: {
    list: [
      {
        id: "family", Obszar roboczy
        : "~/. penclaw/workspace-family",
        sandbox: {
          mode: "all", zakres
          : „agent”,
          obszar roboczyDostęp: "ro",
        },
        tools: {
          allow: [
            "read",
            „sessions_list”,
            "sessions_history",
            "sessions_send",
            "sessions_spawn",
            "session_status",
          ], Odmów
          ["write", "edit", "apply_patch", "exec", "process", "browser"],
        },
      },
    ],
  },
}

{
  agents: {
    list: [
      {
        id: "public", Obszar roboczy
        : "~/. penclaw/workspace-public",
        sandbox: {
          mode: "all", zakres
          : „agent”,
          obszar roboczyDostęp: "brak",
        },
        narzędzi: {
          allow: [
            "sessions_list",
            "sessions_history",
            "sessions_send",
            "sessions_spawn",
            "session_status",
            „whatsapp”,
            „telegram”,
            "slack",
            "discord",
            „bramy internetowe”,
          Odmowa
          [
            "read",
            „pisz”,
            "edytuj",
            „apply_patch”,
            "exec",
            „proces”,
            "przeglądarka",
            „płótna”,
            "węzły",
            „cron”,
            „brama”,
            "obraz",
          ],
        },
      },
    ],
  },
}

{
  agents: {
    list: [
      { id: "home", domyślnie: true, obszar roboczy: "~/. penclaw/workspace-home" },
      { id: "work", workspace: "~/. penclaw/workspace-work" },
    ],
  },
  bindings: [
    { agentId: "home", pasuje: { channel: "whatsapp", accountId: "personal" } },
    { agentId: "work", match: { channel: "whatsapp", ID konta: "biz" } },
  ],
  kanałów: {
    whatsapp: {
      accounts: {
        personal: {},
        biz: {},
      },
    },
  },
}

​

tools.agentToAgent (opcjonalnie)

{
  tools: {
    agentToAgent: {
      enabled: false,
      allow: ["home", "work"],
    },
  },
}

​

messages.quKoleje

{
  wiadomości: {
    kolejka: {
      mode: "collect", // steer | kontynuacja | zbierz | steer-backlog (steer+backlog ok) | przerwaj (kolejka=spis sterowania)
      depozycje: 1000,
      cap: 20,
      drop: "summarize", // old | new | summarize
      byChannel: {
        whatsapp: "collect",
        telegram: "collect",
        discord: "collect",
        imesage: "collect",
        webchat: "collect",
      },
    },
  },
}

​

messages.inbound

{
  wiadomości: {
    przychody: {
      Depozyty Ms: 2000, // 0 wyłącza
      byChannel: {
        whatsapp: 5000, luz
        : 1500,
        discord: 1500,
      },
    },
  },
}

• Odbiór partii wiadomości tylko tekstowo; media / załączniki natychmiast spłudzają.
• Polecenia sterowania (np. /qukoleje, /new) bypass debouncing tak, aby pozostawały w stanie samodzielnym.

​

komendy (obsługa poleceń czatu)

{
  polecenia: {
    native: "auto", // rejestruje natywne polecenia kiedy obsługiwane (auto)
    tekst: true, // analizuj polecenia ukośne w wiadomościach czatu
    : fałsz, // zezwól ! (alias: /bash) (tylko host; wymaga narzędzi. utlenione listy dozwolone)
    bashForegroundMs: 2000, // bash okno (0 tła natychmiast)
    config: false, // zezwól /config (zapisy na dysk)
    debugowanie: false, // zezwól /debugowanie (nadpisywanie tylko uruchomienia)
    restart: fałsz, // zezwól /restart + narzędzie do ponownego uruchomienia bramki
    Użyj Grup dostępu: true, // wymuś listy uprawnień/zasady dla komend
  },
}

• Komendy tekstowe muszą być wysyłane jako wiadomość standalone i użyć wiodącego / (brak aliasów tekstowych).
• commands.text: false wyłącza wysyłanie wiadomości na czacie dla poleceń.
• commands.native: "auto" (domyślnie) włącza natywne polecenia dla Discord/Telegram i zostawia Slack wyłączony; nieobsługiwane kanały pozostają tylko tekstem.
• Ustaw commands.native: true|false aby wymusić wszystko lub nadpisać dla każdego kanału channels.discord.commands.native, channels.telegram.commands.native, channels.slack.commands.native (bool lub "auto"). false usuwa poprzednio zarejestrowane polecenia na Discordzie/Telegramie przy starcie; polecenia Slack są zarządzane w aplikacji Slack
• channels.telegram.customCommands dodaje dodatkowe wpisy do menu bota Telegram. Nazwy są znormalizowane; konflikty z natywnymi poleceniami są ignorowane.
• commands.bash: true włącza ! <cmd> do uruchamiania poleceń powłoki hosta (/bash <cmd> działa również jako alias). Wymaga tools.elevated.enabled i pozwala nadawcy na wpisanie tools.elevated.allowFrom.<channel>.
• commands.bashForegroundMs kontroluje, jak długo czeka na tło. Gdy praca w bash jest uruchomiona, nowy ! <cmd> żądania zostały odrzucone (jeden naraz).
• commands.config: true włącza /config (reads/writes openclaw.json).
• kanały.<provider>Bramki Bramki .configWrites zapoczątkowane przez ten kanał (domyślnie: true). Dotyczy to /config set|unset plus auto-migracje specyficzne dla dostawcy (zmiany identyfikatora supergrupy Telegram, zmiany identyfikatora kanału Slack).
• commands.debug: true włącza /debug (nadpisywanie tylko do uruchomienia).
• commands.restart: true włącza /restart i czynność ponownego uruchomienia narzędzia bramy.
• commands.useAccessGroups: false pozwala poleceniom omijać listy uprawnień/zasady grup dostępu.
• Polecenia slash i dyrektywy są honorowane wyłącznie dla autoryzowanych nadawców. Autoryzacja pochodzi z kanału Zezwalaj/parowanie plus commands.useAccessGroups.

​

web (WhatsApp Web channel runtime)

{
  web: {
    enabled: true,
    heartbeatSeconds: 60,
    ponownie połączy: {
      inicjały: 2000,
      maxMs: 120000,
      czynnik: 1. ,
      uderzenia: 0. ,
      maxAttempts: 0,
    },
  },
}

​

channels.telegram (transport botów)

{
  kanałów: {
    telegram: {
      włączone: true,
      botToken: "your-bot-token",
      dmPolicy: "parowanie", // parowanie | allowlist | open | disabled
      allowFrom: ["tg:123456789"], // opcjonalne; "open" wymaga ["*"]
      grup: {
        "*": { requireMention: true },
        "-1001234567890": {
          allowFrom: ["@admin"],
          SystemPromp: "Zachowaj odpowiedzi krótko. ,
          tematów: {
            "99": {
              requireMention: false,
              umiejętności: ["Szukaj"],
              SystemPromp: "Zostań w temacie. ,
            },
          },
        },
      },
      customCommands: [
        { command: "backup", opis: "Git backup" },
        { command: "generate", opis: "Utwórz obraz" },
      ],
      HistoryLimit: 50, // dołącz ostatnie N wiadomości grupowych jako kontekst (0 wyłączonych)
      replyToMode: "first", // wył | najpierw | wszystkie linki
      : true, // przełącz podgląd połączeń wychodzących
      streamMode: "częściowe", // wyłączone | częściowe | blok (szkic streamingu; oddziel od streamingu blokowego)
      draftChunk: {
        // opcjonalne; tylko dla streamMode=block
        minChars: 200,
        maxChars: 800,
        breakPreference: "paragraph", // akapit | nowa linia | zdanie
      },
      akcji: { reactions: true, sendMessage: true }// bramki akcji narzędzia (fałszywie wyłączone)
      Powiadomienia reakcji: "własne", // off | własne | wszystkie
      mediaMaxMb: 5,
      powtórzeń: {
        // wychodzące zasady powtórzenia
        prób: 3,
        minOpóźnienia: 400,
        maxDelayMs: 30000,
        uderzenie: 0. ,
      }, Sieć
      : {
        // transport nadpisuje
        autoSelectFamily: false,
      },
      proxy: "socks5://localhost:9050",
      webhookUrl: "https://example. om/telegram-webhook", // wymaga webhookSecret
      webhookSecret: "secret",
      webhookPath: "/telegram-webhook",
    },
  },
}

• Używa Telegram sendMessageDraft (szkic bańki, a nie prawdziwej wiadomości).
• Wymaga prywatnych wątków czatu (message_thread_id w DMs; bot ma włączone tematy).
• Rozumowanie strumieni /reasoning stream do szkicu, a następnie wysyła ostateczną odpowiedź. Ponownie spróbuj domyślnych reguł i zachowań są udokumentowane w Reguła próby.

​

channels.discord (transport botów)

{
  kanałów: {
    discord: {
      włączone: true, Token
      : "your-bot-token",
      mediaMaxMb: 8, // clamp przychodzący rozmiar
      zezwala: fałsz, // zezwalaj na bot-autorowane wiadomości
      akcje: {
        // bramki akcji narzędzia (false disables)
        reakcje: true, Naklejki
        : prawda,
        ankiet: prawda, Uprawnienia
        : prawda,
        wiadomości: true,
        wątki: true,
        piny: true,
        search: true,
        userInfo: true,
        role Info: true, Rola
        : false,
        channelInfo: true,
        voiceStatus: true,
        zdarzeń: prawda,
        moderacja: fałsz,
      },
      replyToMode: "off", // wył. | najpierw | wszystkie
      dm: {
        włączone: true, // wyłącz wszystkie pamięci DM, gdy reguła false
        : "parowanie", // parowanie | allowlist | open | disabled
        allowFrom: ["1234567890", "steipete"], // opcjonalna lista dozwolonych DM ("open" wymaga ["*"])
        grupowe: false, // włącz grupę DM.
        groupChannels: ["openclaw-dm"], // opcjonalna lista DM grupy DM
      },
      gildii: {
        "123456789012345678": {
          // id gildii (preferowany) lub slug
          slug: "friends-of-openclaw",
          Wymaganie: fałszywe, // / per -guild default
          Notifications "own", // off | własne | wszystkie | allowlist
          użytkowników: ["987654321098765432"], // opcjonalna lista użytkownika dla gildii
          kanałów: {
            ogólnie: { allow: true },
            pomoc: {
              zezwól na: true, Wymaganie
              : prawda,
              użytkowników: ["987654321098765432"],
              umiejętności: ["docs"], Pysk systemowy
              : "Tylko krótkie odpowiedzi. ,
            },
          },
        },
      },
      HistoryLimit: 20, // dołącz ostatnie N wiadomości gildii jako kontekst
      textChunkLimit: 2000, // opcjonalny rozmiar fragmentu tekstu wychodzącego (znaków)
      tryb chunkMode: "length", // opcjonalny tryb chunking (długość | nowy)
      maxLinesPerMessage: 17, // soft max linii na wiadomość (Discord UI clipping)
      powtórzenia: {
        // wychodzące zasady retry
        prób: 3,
        minOpóźnienia: 500,
        maxDelayMs: 30000,
        jitter: 0. ,
      },
    },
  },
}

• off: brak zdarzeń reakcji.
• own: reakcje na własnych wiadomościach bota (domyślnie).
• all: wszystkie reakcje na wszystkich wiadomościach.
• allowlist: reakcje od guilds.<id>.users na wszystkich wiadomościach (pusta lista wyłącza). Tekst wychodzący jest chunkowany przez channels.discord.textChunkLimit (domyślnie 2000). Ustaw channels.discord.chunkMode="newline" aby podzielić na puste linie (granice paragrafów) przed wycinaniem długości. Klienci Discorda mogą klipować bardzo wysokie wiadomości, więc channels.discord.maxLinesPerMessage (domyślnie 17) dzieli długie wielowymiarowe odpowiedzi nawet gdy są poniżej 2000 znaków. Ponownie spróbuj domyślnych reguł i zachowań są udokumentowane w Reguła próby.

​

channels.googlechat (Chat API webhook)

{
  kanałów: {
    googlechat: {
      włączone: true,
      serviceAccountFile: "/path/to/service-account. son",
      audienceType: "app-url", // app-url | project-number
      audience: "https://gateway.example. om/googlechat",
      webhookPath: "/googlechat",
      botUser: "users/1234567890", // opcjonalne; ulepsza wzmiankę o wykrywaniu
      dm: {
        włączone: true, polityka
        : „parowanie”, // parowanie | allowlist | open | disabled
        allowFrom: ["users/1234567890"], // opcjonalne; "open" wymaga ["*"]
      },
      groupPolicy: "allowlist",
      grupy: {
        "spaces/AAAA": { allow: true, requireMention: true }
      },
      działania: { reactions: true },
      pisingIndicator: "message",
      mediaMaxMb: 20,
    },
  },
}

• Konto usługi JSON może być wbudowane (serviceAccount) lub oparte na plikach (serviceAccountFile).
• Env fallbacks dla domyślnego konta: GOOGLE_CHAT_SERVICE_ACCOUNT lub GOOGLE_CHAT_SERVICE_ACCOUNT_FILE.
• audienceType + audience musi odpowiadać konfiguracji webhooka aplikacji czatu.
• Użyj spacje/<spaceId> lub użytkowników/<userId|email> podczas ustawiania celów dostawy.

​

channels.slack (tryb gniazda)

{
  channels: {
    slack: {
      enabled: true,
      botToken: "xoxb-...",
      appToken: "xapp-...",
      dm: {
        enabled: true,
        policy: "pairing", // pairing | allowlist | open | disabled
        allowFrom: ["U123", "U456", "*"], // optional; "open" requires ["*"]
        groupEnabled: false,
        groupChannels: ["G123"],
      },
      channels: {
        C123: { allow: true, requireMention: true, allowBots: false },
        "#general": {
          allow: true,
          requireMention: true,
          allowBots: false,
          users: ["U123"],
          skills: ["docs"],
          systemPrompt: "Short answers only.",
        },
      },
      historyLimit: 50, // include last N channel/group messages as context (0 disables)
      allowBots: false,
      reactionNotifications: "own", // off | own | all | allowlist
      reactionAllowlist: ["U123"],
      replyToMode: "off", // off | first | all
      thread: {
        historyScope: "thread", // thread | channel
        inheritParent: false,
      },
      actions: {
        reactions: true,
        messages: true,
        pins: true,
        memberInfo: true,
        emojiList: true,
      },
      slashCommand: {
        enabled: true,
        name: "openclaw",
        sessionPrefix: "slack:slash",
        ephemeral: true,
      },
      textChunkLimit: 4000,
      chunkMode: "length",
      mediaMaxMb: 20,
    },
  },
}

• off: brak zdarzeń reakcji.
• own: reakcje na własnych wiadomościach bota (domyślnie).
• all: wszystkie reakcje na wszystkich wiadomościach.
• allowlist: reakcje z channels.slack.reactionAllowlist na wszystkich wiadomościach (pusta lista wyłączona).

• channels.slack.thread.historyScope kontroluje czy historia wątku jest dla każdego wątku (wątek, domyślny, domyślnie) czy współdzielona przez kanał (kanał).
• channels.slack.thread.inheritParent kontroluje czy nowe sesje wątków odziedziczą transkrypt kanału nadrzędnego (domyślnie: fałsz).

​

channels.mattermost (token bota)

{
  kanałów: {
    mattermost: {
      włączone: true,
      botToken: "mm-token",
      baseUrl: "https://chat. xample. om",
      dmPolicy: "parowanie",
      chatmode: "oncall", // oncall | onmessage | onchar
      oncharPrefixes: [">", "! ],
      textChunkLimit: 4000,
      chunkMode: "length",
    },
  },
}

• oncall (domyślnie): odpowiadaj na wiadomości kanału tylko wtedy, gdy @wspomniała.
• onmessage: odpowiada na każdą wiadomość w kanale.
• onchar: odpowiadaj, gdy wiadomość zaczyna się od prefiksu wyzwalacza (channels.mattermost.oncharPrefixes, domyślnie [">", "!"]).

• Domyślne DM: channels.mattermost.dmPolicy="pairing" (nieznani nadawcy otrzymują kod parowania).
• Publiczne DM-y: channels.mattermost.dmPolicy="open" plus channels.mattermost.allowFrom=["*"].
• Grupy: channels.mattermost.groupPolicy="allowlist" domyślnie (mention-gated). Użyj channels.mattermost.groupAllowFrom aby ograniczyć nadawców.

​

channels.signal (sygnał-cli)

{
  kanałów: {
    sygnał: {
      reactionNotifications: "own", // off | własne | wszystkie | allowlist
      reactionAllowlist: ["+15551234567", "uid:123e4567-e89b-12d3-a456-426614174000"],
      historyLimit: 50, // dołącz ostatnie N wiadomości grupy jako kontekst (0 wyłączonych)
    },
  },
}

• off: brak zdarzeń reakcji.
• own: reakcje na własnych wiadomościach bota (domyślnie).
• all: wszystkie reakcje na wszystkich wiadomościach.
• allowlist: reakcje z channels.signal.reactionAllowlist na wszystkie wiadomości (pusta lista wyłączona).

​

channels.imessage (imsg CLI)

{
  channels: {
    imessage: {
      enabled: true,
      cliPath: "imsg",
      dbPath: "~/Library/Messages/chat.db",
      remoteHost: "user@gateway-host", // SCP for remote attachments when using SSH wrapper
      dmPolicy: "pairing", // pairing | allowlist | open | disabled
      allowFrom: ["+15555550123", "[email protected]", "chat_id:123"],
      historyLimit: 50, // include last N group messages as context (0 disables)
      includeAttachments: false,
      mediaMaxMb: 16,
      service: "auto",
      region: "US",
    },
  },
}

• Wymaga pełnego dostępu na dysku do DB.
• Pierwsza wysyłka poprosi o pozwolenie na automatyzację wiadomości.
• Preferuj ‘chat_id:<id>’ celu. Użyj czatów imsg --limit 20 aby wyświetlić listę czatów.
• channels.imessage.cliPath może wskazywać skrypt wrapper (np. ssh do innego Maca, który uruchamia imsg rpc); użyj kluczy SSH, aby uniknąć zapytań o hasło.
• Dla zdalnych zawijaczy SSH ustaw channels.imessage.remoteHost aby pobrać załączniki za pośrednictwem SCP gdy includeAttachments jest włączone.

#!/usr/bin/env bash
exec ssh -T gateway-host imsg "$@"

​

agents.defaults.workspace

{
  agents: { defaults: { workspace: "~/.openclaw/workspace" } },
}

​

agents.defaults.repoRoot

{
  agents: { defaults: { repoRoot: "~/Projects/openclaw" } },
}

​

agents.defaults.skipBootstrap

{
  agents: { defaults: { skipBootstrap: true } },
}

​

agents.defaults.bootstrapMaxChars

{
  agents: { defaults: { bootstrapMaxChars: 20000 } },
}

​

agents.defaults.userTimezone

{
  agents: { defaults: { userTimezone: "America/Chicago" } },
}

​

agents.defaults.timeFormat

{
  agents: { defaults: { timeFormat: "auto" } }, // auto | 12 | 24
}

​

wiadomości

{
  wiadomości: {
    responsePrefix: "🦞", // lub "auto"
    ackReaction: "👀",
    ackReactionScope: "group-mentions",
    removeAckAfterReply: false,
  },
}

• channels.<channel>.responsePrefix
• channels.<channel>.accounts.<id>.responsePrefix

1. channels.<channel>.accounts.<id>.responsePrefix
2. channels.<channel>.responsePrefix
3. messages.responsePrefix

• undefined przechodzi do następnego poziomu.
• "" wyraźnie wyłącza przedrostek i zatrzymuje kaskadę.
• "auto" uzyskuje [{identity.name}] dla przekierowanego agenta.

​

Zmienne szablonu

{
  wiadomości: {
    responsePrefix: "[{model} | think:{thinkingLevel}]",
  },
}

• group-mentions (domyślnie): tylko wtedy, gdy grupa / pokój wymaga wzmianki i o botu
• group-all: wszystkie wiadomości grupy/pokoju
• direct: tylko bezpośrednie wiadomości
• all: wszystkie wiadomości

​

messages.tts

{
  wiadomości: {
    tts: {
      automatycznie: "zawsze", // off | zawsze | tryb przychodzący | oznaczony
      : "final", // final | wszystkie (zawierają odpowiedzi narzędzi/bloki)
      dostawca: "elevenlabs",
      Podsumowanie: "openai/gpt-4. -mini",
      modelNadpisywanie: {
        enabled: true,
      },
      maxTextLength: 4000,
      timeoutMs: 30000,
      prefsŚcieżka: "~/. ołówek/ustawienia/tts. son",
      elevenlabs: {
        apiKey: "elevenlabs_api_key",
        baseUrl: "https://api. levenlab. o",
        voiceId: "voice_id",
        modelId: "eleven_multilingual_v2",
        seed 42,
        applyTextNormalizacja: "auto",
        languageCode: "en",
        voiceSettings: {
          stability: 0. ,
          podobieństwo Boost: 0. Styl 5,
          : 0. ,
          useSpeakerBoost: true, Prędkość
          : 1. ,
        },
      },
      openai: {
        apiKey: "openai_api_key",
        model: "gpt-4o-mini-tts",
        głos: "stopy",
      },
    },
  },
}

• messages.tts.auto kontroluje auto-TTS (off, zawsze, inbound, ttaged).
• /tts off|zawsze|inbound|ttaged ustawia tryb auto sesji (nadpisuje konfigurację).
• messages.tts.enabled jest legacy; lekarz migruje go do messages.tts.auto.
• prefsPath przechowuje lokalne nadpisania (provider/limit/summarize).
• maxTextLength jest twardym limitem wejścia TTS; podsumowania są obcięte, aby pasować.
• summaryModel zastępuje agents.defaults.model.primary dla automatycznego podsumowania.
  • Akceptuje provider/model lub alias z agents.defaults.models.
• modelOverrides umożliwia generowane przez model nadpisywanie tagów [[tts:...] (domyślnie).
• Ustawienia podsumowania /tts limit i /tts summary dla każdego użytkownika.
• Wartości apiKey wracają do ELEVENLABS_API_KEY/XI_API_KEY i OPENAI_API_KEY.
• elevenlabs.baseUrl zastępuje bazowy adres URL API ElevenLabs.
• elevenlabs.voiceSettings obsługuje stability/similarityBoost/style (0..1), useSpeakerBoost, i speed (0.5..2.0).

​

talk

{
  talk: {
    voiceId: "elevenlabs_voice_id",
    voiceAliases: {
      Clawd: "EXAVITQu4vr4xnSDxMaL",
      Roger: "CwhRBWXzGAHq8TQ4Fs17",
    },
    modelId: "eleven_v3",
    outputFormat: "mp3_44100_128",
    apiKey: "elevenlabs_api_key",
    interruptOnSpeech: true,
  },
}

​

agents.defaults

• alias (opcjonalny skrót modelowy, np. /opus).
• params (opcjonalne parametry API specyficzne dla dostawcy, przekazane do żądania modelu).

{
  agents: {
    domyślnie: {
      models: {
        "anthropic/claude-sonnet-4-5-20250929": {
          params: { temperature: 0.6 },
        },
        "openai/gpt-5. ": {
          parametry: { maxTokens: 8192 },
        },
      },
    },
  },
}

• ustaw --thinking wyłączony, lub
• definiuj agents.defaults.models["zai/<model>"].params.thinking.

• opus -> anthropic/claude-opus-4-6
• sonnet -> anthropic/claude-sonnet-4-5
• gpt -> openai/gpt-5.2
• gpt-mini -> openai/gpt-5-mini
• gemini -> google/gemini-3-pro-preview
• gemini-flash -> google/gemini-3-flash-preview

{
  agents: {
    defaults: {
      models: {
        "anthropic/claude-opus-4-6": { alias: "opus" },
        "minimax/MiniMax-M2. ": { alias: "minimax" },
      }, Model
      : {
        primary: "anthropic/claude-opus-4-6",
        spada: ["minimax/MiniMax-M2. "],
      },
    },
  },
}

​

agents.defaults.cliBackends (CLI fallback)

• backendy CLI są tekst-first; narzędzia są zawsze wyłączone.
• Sesje są obsługiwane, gdy ustawiona jest sessionArg; identyfikatory sesji są utrzymywane na zapleczu.
• Dla claude-cli, domyślne ustawienia są włączone. Zastąp ścieżkę poleceń, jeśli PATH jest minimalny (uruchomiony/system).

{
  agents: {
    domyślnie: {
      cliBackends: {
        "claude-cli": {
          command: "/opt/homebrew/bin/claude",
        },
        "my-cli": {
          command: "my-cli",
          args: ["--json"], Wyjście
          : „json”,
          modelArg: "--model", sesja
          Arg: "--session", Tryb sesyjny
          : "istnieje",
          systemPromptArg: "--system",
          systemPromptWhen: "first",
          imageArg: "--image", Tryb obrazka
          : "repeat",
        },
      },
    },
  },
}

{
  agents: {
    defaults: {
      models: {
        "anthropic/claude-opus-4-6": { alias: "Opus" },
        "anthropic/claude-sonnet-4-1": { alias: "Sonnet" },
        "openrouter/deepseek/deepseek-r1:free": {},
        "zai/glm-4. ": {
          alias: "GLM", Parametry
          : {
            myślenie: {
              type: "enabled",
              clear_myśli: fałszywe,
            },
          },
        },
      }, Model
      : {
        primary: "anthropic/claude-opus-4-6",
        wypada: [
          "openrouter/deepseek/deepseek-r1:free",
          "openrouter/meta-llama/llama-3. -70b-instruct:free",
        ],
      },
      imageModel: {
        primary: "openrouter/qwen/qwen-2. -vl-72b-instruct:free",
        upada: ["openrouter/google/gemini-2. -flash-vision:free"],
      },
      thinkingDefault: "low",
      verboseDefault: "off", Domyślny wzrost
      : "on",
      timeoutSeconds: 600,
      mediaMaxMb: 5,
      uderzenie serca: {
        zawsze: "30m", Cel
        : "ostatni",
      },
      maksymalnie: 3,
      subagentów: {
        model: "minimax/MiniMax-M2. ",
        maxConcurrent: 1,
        archiveAfterMinutes: 60,
      },
      exec: {
        tła: 10000,
        timeoutSec: 1800,
        czyszczenia: 1800000,
      },
      contextTokens: 200000,
    },
  },
}

​

agents.defaults.contextPruning (przybornik efektu)

• Nigdy nie dotyka wiadomości użytkownika/asystenta.
• Chroni ostatnie wiadomości asystenta keepLastAssistants (nie ma wyników narzędzia po tym punkcie są prundy).
• Chroni prefiks bootstrap (nie ma nic przed wyciskaniem pierwszej wiadomości użytkownika).
• Tryby:
  • adaptive: wyniki narzędzi o rozmiarze nadmiaru (zachowaj głowę/ogon), gdy szacowany stosunek kontekstu przecina softTrimRatio. Następnie twardo wyczyści najstarsze kwalifikujące się narzędzia gdy szacowany współczynnik kontekstu przecina hardClearRatio i jest wystarczająco dużo narzędzia prądowego (minPrunableToolChars).
  • aggressive: zawsze zastępuje kwalifikujące się wyniki narzędzia przed odcięciem hardClear.placeholder (brak kontroli).

• Soft-trim: tylko dla wyników narzędzi nadrozmiaru Zachowuje początek + koniec i umieszcza ... w środku.
  • Przed: toolResult("…bardzo długi wyjście…")
  • Po: toolResult("HEAD…\n...\n…TAIL\n\n[Tool result trimmed: …]")
• Trudno wyjaśnić: zastępuje cały wynik narzędzia symbolem zastępczym.
  • Przed: toolResult("…bardzo długi wyjście…")
  • Po: toolResult("[Old tool result content cleard]")

• Wyniki narzędzi zawierające bloki obrazów są pomijane (nigdy nie przycięte/wyczyszczone).
• Oszacowany „współczynnik kontekstu” opiera się na znakach (przybliżonym), a nie dokładnych tokenach.
• Jeśli sesja nie zawiera jeszcze co najmniej wiadomości asystenta keepLastAssistants, odprawa jest pomijana.
• W trybie aggressive hardClear.enabled jest ignorowany (kwalifikujące się wyniki narzędzia są zawsze zastępowane hardClear.placeholder).

{
  agents: { defaults: { contextPruning: { mode: "adaptive" } },
}

{
  agents: { defaults: { contextPruning: { mode: "off" } },
}

• keepLastAssistants: 3
• softTrimRatio: 0.3 (tylko adaptacyjne)
• hardClearRatio: 0.5 (tylko adaptacyjne)
• minPrunableToolChars: 50000 (tylko adaptacyjne)
• softTrim: { maxChars: 4000, headChars: 1500, tailChars: 1500 } (tylko adaptacyjne)
• hardClear: { enabled: true, placeholder: "[Old tool result content cleared]" }

{
  agents: { defaults: { contextPruning: { mode: "aggressive" } },
}

{
  agents: {
    defaults: {
      contextPruning: {
        mode: "adaptive",
        zachowuje Asystentów: 3,
        softTrimRatio: 0. ,
        hardClearRatio: 0. ,
        minunableToolChars: 50000,
        softTrim: { maxChars: 4000, headChars: 1500, tailChars: 1500 },
        hardClear: { enabled: true, zamiennik: "[Zawartość rezultatu starego narzędzia wyczyszczona]" },
        // Opcjonalnie: Ogranicz wycinanie do konkretnych narzędzi (odrzuć wygrane; obsługuje "*" wildcards)
        tools: { deny: ["browser", "canvas"] },
      },
    },
  },
}

​

agents.defaults.compaction (zarezerwuj pokój głowy + opróżnianie pamięci)

• memoryFlush.enabled: true
• memoryFlush.softThresholdTokens: 4000
• memoryFlush.prompt / memoryFlush.systemPrompt: wbudowane domyślne ustawienia z NO_REPLY
• Uwaga: pamięć jest pominięta, gdy obszar roboczy sesji jest tylko do odczytu (agents.defaults.sandbox.workspaceAccess: "ro" lub "none").

{
  agents: {
    defaults: {
      compaction: {
        mode: "Securard",
        reserveTokensFloor: 24000,
        memoryFlush: {
          włączone: true,
          softThresholdTokens: 6000,
          SystemPrompt: "Sesja zbliżająca się do zagęszczania. Przechowuj teraz trwałe pamięci.",
          wskazówka: "Zapisz wszelkie trwałe notatki do pamięci/RRRR-MM-DD. d; odpowiedz NO_REPLY, jeśli nic nie ma do przechowywania. ,
        },
      },
    },
  },
}

• agents.defaults.blockStreamingDefault: "on"/"off" (domyślnie wyłączone).
• Nadpisywanie kanałów: *.blockStreaming (i warianty dla każdego konta) wymusza włączanie/wyłączanie blokowania streamingu. Kanały inne niż Telegram wymagają wyraźnego *.blockStreaming: true aby włączyć odpowiedzi bloku.
• agents.defaults.blockStreamingBreak: "text_end" lub "message_end" (domyślnie: text_end).
• agents.defaults.blockStreamingChunk: miękki chunking dla bloków strumieniowych. Domyślnie 800–1200 znaków, preferowane są przerwy w paragrafie (\n\n), potem nowe, potem zdania. Przykład:
  {
    agents: { defaults: { blockStreamingChunk: { minChars: 800, maxChars: 1200 } } },
  }
  
• agents.defaults.blockStreamingCoalesce: scalanie strumieniowych bloków przed wysłaniem. Domyślnie { idleMs: 1000 } i dziedziczy minChars z blockStreamingChunk z maxChars ograniczonym do limitu tekstu kanału. Sygnał/Slack/Discord/Google Chat domyślnie do minChars: 1500, chyba że nadpisano. Nadpisuje kanał: channels.whatsapp.blockStreamingCoalesce, channels.telegram.blockStreamingCoalesce, channels.discord.blockStreamingCoalesce, kanałs.slack.blockStreamingCoalesce, channels.mattermost.blockStreamingCoalesce, channels.signal.blockStreamingCoalesce, channels.imessage.blockStreamingCoalesce, channels.msteams.blockStreamingCoalesce, channels.googlechat.blockStreamingCoalesce (i warianty na konto).
• agents.defaults.humanDelay: losowa pauza pomiędzy odpowiedziami bloku po pierwszej. Mody: off (domyślnie), natural (800–2500ms), custom (użyj minMs/maxMs). Nadpisywanie peragenta: agents.list[].Ludzkie Opóźnienie. Przykład:
  {
    agents: { defaults: { humanDelay: { mode: "natural" } },
  }
  
  Zobacz /concepts/streaming dla zachowania + szczegóły chunkingu.

• agents.defaults.typingMode: "niver" | "instant" | "thinking" | "message". Domyślnie instant dla czatów bezpośrednich / wzmianek i message dla niewymienionych czatów grupowych.
• session.typingMode: nadpisanie trybu na sesję.
• agents.defaults.typingIntervalSeconds: jak często sygnał pisania jest odświeżany (domyślnie: 6s).
• session.typingIntervalSeconds: dla każdej sesji nadpisanie odstępu odświeżania. Zobacz /concepts/typing-indicators, aby uzyskać szczegóły zachowań.

• every: ciąg czasu trwania (ms, s, m, h); domyślne minuty jednostki. Domyślnie: 30m. Ustaw 0m aby wyłączyć.
• model: opcjonalne nadpisanie modelu dla akcji serca (provider/model).
• includeReasoning: kiedy true, uderzenia serca również dostarczą oddzielną wiadomość Reasoning: jeśli jest dostępna (taki sam kształt jak /rozumowanie na ). Domyślnie: false.
• sesja: opcjonalny klucz sesji do kontrolowania, w której zaczyna się sesja bicia serca. Domyślnie: main.
• do: opcjonalne nadpisanie odbiorcy (identyfikator specyficzny dla kanału, np. E.164 dla WhatsApp, identyfikator czatu dla Telegram).
• target: opcjonalny kanał dostawy (last, whatsapp, telegram, discord, slack, msteams, signal, imessage, none). Domyślnie: last.
• prompt: opcjonalnie nadpisz ciało bicia serca (domyślnie: Read HEARTBEAT.md jeśli istnieje (kontekst obszaru roboczego). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK.). Nadpisania są wysyłane w słowniku; jeśli nadal chcesz przeczytać plik wpisz wiersz “Przeczytaj HEARTBEAT.md”.
• ackMaxChars: maksymalna ilość znaków dozwolonych po HEARTBEAT_OK przed dostawą (domyślnie: 300).

• Ustaw agents.list[].heartbeat aby włączyć lub zastąpić ustawienia bicia serca dla konkretnego agenta.
• Jeśli jakakolwiek pozycja agenta definiuje heartbeat, tylko te czynniki uruchamiają bicie serca; domyślnie staje się wspólną linią podstawową dla tych czynników.

• tłoMs: czas przed auto-tłem (ms, domyślnie 10000)
• timeoutSec: automatyczne zabijanie po tym czasie (sekundy, domyślnie 1800)
• cleanupMs: jak długo zachować ukończone sesje w pamięci (ms, domyślnie 1800000)
• notifyOnExit: dodaj do kolejki zdarzenie systemowe + poproś o bicie serca po wyjściu z tła (domyślnie prawda)
• applyPatch.enabled: włącz eksperymentalne apply_patch (OpenAI/OpenAI Codex tylko domyślnie; false)
• applyPatch.allowModels: opcjonalna dopuszczalna lista identyfikatorów modelu (np. gpt-5.2 lub openai/gpt-5.2) Uwaga: applyPatch jest tylko pod tools.exec.

• tools.web.search.enabled (domyślnie: true gdy klawisz jest obecny)
• tools.web.search.apiKey (zalecane: ustaw za pomocą openclaw configure --section web, lub użyj BRAVE_API_KEY env var)
• tools.web.search.maxResults (1–10, domyślnie 5)
• tools.web.search.timeoutSeconds (domyślnie 30)
• tools.web.search.cacheTtlMinutes (domyślnie 15)
• tools.web.fetch.enabled (domyślnie prawda)
• tools.web.fetch.maxChars (domyślnie 50000)
• tools.web.fetch.maxCharsCap (domyślnie 50000; clamps maxChars from config/toolcalls)
• tools.web.fetch.timeoutSeconds (domyślnie 30)
• tools.web.fetch.cacheTtlMinutes (domyślnie 15)
• tools.web.fetch.userAgent (opcjonalne nadpisanie)
• tools.web.fetch.readability (domyślnie true; wyłącz tylko do czyszczenia HTML)
• tools.web.fetch.firecrawl.enabled (domyślnie prawda, gdy klucz API jest ustawiony)
• tools.web.fetch.firecrawl.apiKey (opcjonalne; domyślnie FIRECRAWL_API_KEY)
• tools.web.fetch.firecrawl.baseUrl (domyślnie https://api.firecrawl.dev)
• tools.web.fetch.firecrawl.onlyMainContent (domyślnie prawda)
• tools.web.fetch.firecrawl.maxAgeMs (opcjonalne)
• tools.web.fetch.firecrawl.timeoutSeconds (opcjonalne)

• tools.media.models: lista modeli współdzielonych (cap-lists).
• tools.media.concurrency: max jednoczesne uruchamianie zdolności (domyślnie 2).
• tools.media.image / tools.media.audio / tools.media.video:
  • enabled: opt-out przełącznik (domyślnie true gdy modele są skonfigurowane).
  • prompt: opcjonalne nadpisanie polecenia (image/video dołącz hint maxChars automatycznie).
  • maxChars: maksymalna ilość znaków wyjściowych (domyślnie 500 dla zdjęcia/wideo; nieustawione dla audio).
  • maxBytes: maksymalny rozmiar multimediów do wysłania (domyślnie: obraz 10MB, dźwięk 20MB, wideo 50MB).
  • timeoutSeconds: limit czasu żądania (domyślnie: obrazek 60, dźwięk 60, film 120).
  • język: opcjonalna podpowiedź dźwiękowa.
  • załączniki: zasady załączników (mode, maxAttachments, preferowane ).
  • zakresu: opcjonalna bramka (pierwsza wygrana meczu) z match.channel, match.chatType, lub match.keyPrefix.
  • models: uporządkowana lista wpisów modelu; błędy lub nadwymiary mediów wracają do następnego wpisu.
• Każdy wpis models[]:
  • Wpis dostawcy (type: "provider" lub pominięty):
    • provider: identyfikator dostawcy API (openai, anthropic, google/gemini, groq, itp.).
    • model: nadpisanie identyfikatora modelu (wymagane dla obrazu; domyślnie gpt-4o-mini-transcribe/whisper-big v3-turbo dla dostawców audio i gemini-3-flash-preview dla wideo).
    • profile / preferowane profile: wybór profilu autoryzacji.
  • Wpis CLI (type: "cli"):
    • komenda: wykonywalny do uruchomienia.
    • args: templated args (obsługuje {{MediaPath}}, {{Prompt}}, {{MaxChars}}, etc).
  • zdolności: opcjonalna lista (image, audio, video) do bramki wspólnego wpisu. Domyślnie, gdy pominięto: openai/anthropic/minimax → obraz, google → obraz+audio+video, groq → audio.
  • prompt, maxChars, maxBytes, timeoutSeconds, language może zostać zastąpiony na wpis.

{
  tools: {
    media: {
      audio: {
        włączone: true,
        maxBajty: 20971520, Zakres
        : {
          domyślnie: "deny", Reguły
          : [{ action: "allow", dopasowanie: { chatType: "direct" } }],
        },
        modele: [
          { provider: "openai", model: "gpt-4o-mini-transcribe" },
          { type: "cli", command: "whisper", args: ["--model", "base", "{{MediaPath}}"] },
        ],
      }, Film
      : {
        włączony: true,
        maxBytes: 52428800,
        modely: [{ provider: "google", model: "gemini-3-flash-preview" }],
      },
    },
  },
}

• model: domyślny model dla spawanych podagentów (ciąg znaków lub { primary, fallbacks }). W przypadku pominięcia subagenci dziedziczą model dzwoniącego, chyba że zostanie on zastąpiony przez jednego przedstawiciela lub jednego połączenia.
• maxConcurrent: max jednoczesny subagent (domyślnie 1)
• archiveAfterMinutes: automatyczne archiwizowanie sesji subagenta po N minutach (domyślnie 60; ustaw 0 na wyłączony)
• Polityka narzędzi dla subagenta: tools.subagents.tools.allow / tools.subagents.tools.deny (odmawiaj zwycięstw)

• minimal: tylko session_status
• coding: group:fs, group:runtime, group:sessions, group:memory, image
• messaging: group:messaging, sessions_list, sessions_history, sessions_send, session_status
• full: brak ograniczeń (tak samo jak brak ustawienia)

{
  tools: {
    profile: "messaging",
    allow: ["slack", "discord"],
  },
}

{
  tools: {
    profile: "coding",
    deny: ["group:runtime"],
  },
}

{
  tools: {
    profile: "coding",
    byProvider: {
      "google-antigravity": { profile: "minimal" },
    },
  },
}

{
  tools: {
    allow: ["group:fs", "group:runtime", "sessions_list"],
    byProvider: {
      "openai/gpt-5.2": { allow: ["group:fs", "sessions_list"] },
    },
  },
}

{
  tools: { deny: ["browser", "canvas"] },
}

• group:runtime: exec, bash, process
• group:fs: read, write, edit, apply_patch
• group:sessions: sessions_list, sessions_history, sessions_send, sessions_spawn, session_status
• group:memory: memory_search, memory_get
• group:web: web_search, web_fetch
• group:ui: browser, canvas
• group:automation: cron, gateway
• group:messaging: message
• group:nodes: nodes
• group:openclaw: wszystkie wbudowane narzędzia OpenClaw (z wyłączeniem wtyczek dostawców)

• enabled: włącz tryb podwyższony (domyślnie prawda)
• allowFod: dozwolone listy na kanał (puste = wyłączone)
  • whatsapp: Numery E.164
  • telegram: identyfikatory czatu lub nazwy użytkowników
  • discord: identyfikatory użytkownika lub nazwy użytkowników (powróci do channels.discord.dm.allowFrom, jeśli zostaniesz pominięty)
  • sygnał: liczby E.164
  • imessage: handles/chat id
  • webchat: identyfikatory sesji lub nazwy użytkowników

{
  tools: {
    elevated: {
      enabled: true,
      allowFrom: {
        whatsapp: ["+15555550123"],
        discord: ["steipete", "1234567890123"],
      },
    },
  },
}

{
  agents: {
    list: [
      {
        id: "family", Narzędzia
        : {
          podwyższone: { enabled: false },
        },
      },
    ],
  },
}