@takibeiy/moltbot_cn 2026.1.27 → 2026.2.1-beta.1

package/dist/config/talk.js

@@ -8,14 +8,16 @@ export function readTalkApiKeyFromProfile(deps = {}) {
     const home = osImpl.homedir();
     const candidates = [".profile", ".zprofile", ".zshrc", ".bashrc"].map((name) => pathImpl.join(home, name));
     for (const candidate of candidates) {
-        if (!fsImpl.existsSync(candidate))
+        if (!fsImpl.existsSync(candidate)) {
             continue;
+        }
         try {
             const text = fsImpl.readFileSync(candidate, "utf-8");
             const match = text.match(/(?:^|\n)\s*(?:export\s+)?ELEVENLABS_API_KEY\s*=\s*["']?([^\n"']+)["']?/);
             const value = match?.[1]?.trim();
-            if (value)
+            if (value) {
                 return value;
+            }
         }
         catch {
             // Ignore profile read errors.
@@ -25,7 +27,8 @@ export function readTalkApiKeyFromProfile(deps = {}) {
 }
 export function resolveTalkApiKey(env = process.env, deps = {}) {
     const envValue = (env.ELEVENLABS_API_KEY ?? "").trim();
-    if (envValue)
+    if (envValue) {
         return envValue;
+    }
     return readTalkApiKeyFromProfile(deps);
 }

package/dist/config/telegram-custom-commands.d.ts

@@ -0,0 +1,24 @@
+export declare const TELEGRAM_COMMAND_NAME_PATTERN: RegExp;
+export type TelegramCustomCommandInput = {
+    command?: string | null;
+    description?: string | null;
+};
+export type TelegramCustomCommandIssue = {
+    index: number;
+    field: "command" | "description";
+    message: string;
+};
+export declare function normalizeTelegramCommandName(value: string): string;
+export declare function normalizeTelegramCommandDescription(value: string): string;
+export declare function resolveTelegramCustomCommands(params: {
+    commands?: TelegramCustomCommandInput[] | null;
+    reservedCommands?: Set<string>;
+    checkReserved?: boolean;
+    checkDuplicates?: boolean;
+}): {
+    commands: Array<{
+        command: string;
+        description: string;
+    }>;
+    issues: TelegramCustomCommandIssue[];
+};

package/dist/config/telegram-custom-commands.js

@@ -1,8 +1,9 @@
 export const TELEGRAM_COMMAND_NAME_PATTERN = /^[a-z0-9_]{1,32}$/;
 export function normalizeTelegramCommandName(value) {
     const trimmed = value.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return "";
+    }
     const withoutSlash = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
     return withoutSlash.trim().toLowerCase();
 }

package/dist/config/types.agent-defaults.d.ts

@@ -0,0 +1,248 @@
+import type { ChannelId } from "../channels/plugins/types.js";
+import type { BlockStreamingChunkConfig, BlockStreamingCoalesceConfig, HumanDelayConfig, TypingMode } from "./types.base.js";
+import type { SandboxBrowserSettings, SandboxDockerSettings, SandboxPruneSettings } from "./types.sandbox.js";
+import type { MemorySearchConfig } from "./types.tools.js";
+export type AgentModelEntryConfig = {
+    alias?: string;
+    /** Provider-specific API parameters (e.g., GLM-4.7 thinking mode). */
+    params?: Record<string, unknown>;
+};
+export type AgentModelListConfig = {
+    primary?: string;
+    fallbacks?: string[];
+};
+export type AgentContextPruningConfig = {
+    mode?: "off" | "cache-ttl";
+    /** TTL to consider cache expired (duration string, default unit: minutes). */
+    ttl?: string;
+    keepLastAssistants?: number;
+    softTrimRatio?: number;
+    hardClearRatio?: number;
+    minPrunableToolChars?: number;
+    tools?: {
+        allow?: string[];
+        deny?: string[];
+    };
+    softTrim?: {
+        maxChars?: number;
+        headChars?: number;
+        tailChars?: number;
+    };
+    hardClear?: {
+        enabled?: boolean;
+        placeholder?: string;
+    };
+};
+export type CliBackendConfig = {
+    /** CLI command to execute (absolute path or on PATH). */
+    command: string;
+    /** Base args applied to every invocation. */
+    args?: string[];
+    /** Output parsing mode (default: json). */
+    output?: "json" | "text" | "jsonl";
+    /** Output parsing mode when resuming a CLI session. */
+    resumeOutput?: "json" | "text" | "jsonl";
+    /** Prompt input mode (default: arg). */
+    input?: "arg" | "stdin";
+    /** Max prompt length for arg mode (if exceeded, stdin is used). */
+    maxPromptArgChars?: number;
+    /** Extra env vars injected for this CLI. */
+    env?: Record<string, string>;
+    /** Env vars to remove before launching this CLI. */
+    clearEnv?: string[];
+    /** Flag used to pass model id (e.g. --model). */
+    modelArg?: string;
+    /** Model aliases mapping (config model id → CLI model id). */
+    modelAliases?: Record<string, string>;
+    /** Flag used to pass session id (e.g. --session-id). */
+    sessionArg?: string;
+    /** Extra args used when resuming a session (use {sessionId} placeholder). */
+    sessionArgs?: string[];
+    /** Alternate args to use when resuming a session (use {sessionId} placeholder). */
+    resumeArgs?: string[];
+    /** When to pass session ids. */
+    sessionMode?: "always" | "existing" | "none";
+    /** JSON fields to read session id from (in order). */
+    sessionIdFields?: string[];
+    /** Flag used to pass system prompt. */
+    systemPromptArg?: string;
+    /** System prompt behavior (append vs replace). */
+    systemPromptMode?: "append" | "replace";
+    /** When to send system prompt. */
+    systemPromptWhen?: "first" | "always" | "never";
+    /** Flag used to pass image paths. */
+    imageArg?: string;
+    /** How to pass multiple images. */
+    imageMode?: "repeat" | "list";
+    /** Serialize runs for this CLI. */
+    serialize?: boolean;
+};
+export type AgentDefaultsConfig = {
+    /** Primary model and fallbacks (provider/model). */
+    model?: AgentModelListConfig;
+    /** Optional image-capable model and fallbacks (provider/model). */
+    imageModel?: AgentModelListConfig;
+    /** Model catalog with optional aliases (full provider/model keys). */
+    models?: Record<string, AgentModelEntryConfig>;
+    /** Agent working directory (preferred). Used as the default cwd for agent runs. */
+    workspace?: string;
+    /** Optional repository root for system prompt runtime line (overrides auto-detect). */
+    repoRoot?: string;
+    /** Skip bootstrap (BOOTSTRAP.md creation, etc.) for pre-configured deployments. */
+    skipBootstrap?: boolean;
+    /** Max chars for injected bootstrap files before truncation (default: 20000). */
+    bootstrapMaxChars?: number;
+    /** Optional IANA timezone for the user (used in system prompt; defaults to host timezone). */
+    userTimezone?: string;
+    /** Time format in system prompt: auto (OS preference), 12-hour, or 24-hour. */
+    timeFormat?: "auto" | "12" | "24";
+    /**
+     * Envelope timestamp timezone: "utc" (default), "local", "user", or an IANA timezone string.
+     */
+    envelopeTimezone?: string;
+    /**
+     * Include absolute timestamps in message envelopes ("on" | "off", default: "on").
+     */
+    envelopeTimestamp?: "on" | "off";
+    /**
+     * Include elapsed time in message envelopes ("on" | "off", default: "on").
+     */
+    envelopeElapsed?: "on" | "off";
+    /** Optional display-only context window override (used for % in status UIs). */
+    contextTokens?: number;
+    /** Optional CLI backends for text-only fallback (claude-cli, etc.). */
+    cliBackends?: Record<string, CliBackendConfig>;
+    /** Opt-in: prune old tool results from the LLM context to reduce token usage. */
+    contextPruning?: AgentContextPruningConfig;
+    /** Compaction tuning and pre-compaction memory flush behavior. */
+    compaction?: AgentCompactionConfig;
+    /** Vector memory search configuration (per-agent overrides supported). */
+    memorySearch?: MemorySearchConfig;
+    /** Default thinking level when no /think directive is present. */
+    thinkingDefault?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+    /** Default verbose level when no /verbose directive is present. */
+    verboseDefault?: "off" | "on" | "full";
+    /** Default elevated level when no /elevated directive is present. */
+    elevatedDefault?: "off" | "on" | "ask" | "full";
+    /** Default block streaming level when no override is present. */
+    blockStreamingDefault?: "off" | "on";
+    /**
+     * Block streaming boundary:
+     * - "text_end": end of each assistant text content block (before tool calls)
+     * - "message_end": end of the whole assistant message (may include tool blocks)
+     */
+    blockStreamingBreak?: "text_end" | "message_end";
+    /** Soft block chunking for streamed replies (min/max chars, prefer paragraph/newline). */
+    blockStreamingChunk?: BlockStreamingChunkConfig;
+    /**
+     * Block reply coalescing (merge streamed chunks before send).
+     * idleMs: wait time before flushing when idle.
+     */
+    blockStreamingCoalesce?: BlockStreamingCoalesceConfig;
+    /** Human-like delay between block replies. */
+    humanDelay?: HumanDelayConfig;
+    timeoutSeconds?: number;
+    /** Max inbound media size in MB for agent-visible attachments (text note or future image attach). */
+    mediaMaxMb?: number;
+    typingIntervalSeconds?: number;
+    /** Typing indicator start mode (never|instant|thinking|message). */
+    typingMode?: TypingMode;
+    /** Periodic background heartbeat runs. */
+    heartbeat?: {
+        /** Heartbeat interval (duration string, default unit: minutes; default: 30m). */
+        every?: string;
+        /** Optional active-hours window (local time); heartbeats run only inside this window. */
+        activeHours?: {
+            /** Start time (24h, HH:MM). Inclusive. */
+            start?: string;
+            /** End time (24h, HH:MM). Exclusive. Use "24:00" for end-of-day. */
+            end?: string;
+            /** Timezone for the window ("user", "local", or IANA TZ id). Default: "user". */
+            timezone?: string;
+        };
+        /** Heartbeat model override (provider/model). */
+        model?: string;
+        /** Session key for heartbeat runs ("main" or explicit session key). */
+        session?: string;
+        /** Delivery target ("last", "none", or a channel id). */
+        target?: "last" | "none" | ChannelId;
+        /** Optional delivery override (E.164 for WhatsApp, chat id for Telegram). */
+        to?: string;
+        /** Override the heartbeat prompt body (default: "Read HEARTBEAT.md if it exists (workspace context). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK."). */
+        prompt?: string;
+        /** Max chars allowed after HEARTBEAT_OK before delivery (default: 30). */
+        ackMaxChars?: number;
+        /**
+         * When enabled, deliver the model's reasoning payload for heartbeat runs (when available)
+         * as a separate message prefixed with `Reasoning:` (same as `/reasoning on`).
+         *
+         * Default: false (only the final heartbeat payload is delivered).
+         */
+        includeReasoning?: boolean;
+    };
+    /** Max concurrent agent runs across all conversations. Default: 1 (sequential). */
+    maxConcurrent?: number;
+    /** Sub-agent defaults (spawned via sessions_spawn). */
+    subagents?: {
+        /** Max concurrent sub-agent runs (global lane: "subagent"). Default: 1. */
+        maxConcurrent?: number;
+        /** Auto-archive sub-agent sessions after N minutes (default: 60). */
+        archiveAfterMinutes?: number;
+        /** Default model selection for spawned sub-agents (string or {primary,fallbacks}). */
+        model?: string | {
+            primary?: string;
+            fallbacks?: string[];
+        };
+    };
+    /** Optional sandbox settings for non-main sessions. */
+    sandbox?: {
+        /** Enable sandboxing for sessions. */
+        mode?: "off" | "non-main" | "all";
+        /**
+         * Agent workspace access inside the sandbox.
+         * - "none": do not mount the agent workspace into the container; use a sandbox workspace under workspaceRoot
+         * - "ro": mount the agent workspace read-only; disables write/edit tools
+         * - "rw": mount the agent workspace read/write; enables write/edit tools
+         */
+        workspaceAccess?: "none" | "ro" | "rw";
+        /**
+         * Session tools visibility for sandboxed sessions.
+         * - "spawned": only allow session tools to target sessions spawned from this session (default)
+         * - "all": allow session tools to target any session
+         */
+        sessionToolsVisibility?: "spawned" | "all";
+        /** Container/workspace scope for sandbox isolation. */
+        scope?: "session" | "agent" | "shared";
+        /** Legacy alias for scope ("session" when true, "shared" when false). */
+        perSession?: boolean;
+        /** Root directory for sandbox workspaces. */
+        workspaceRoot?: string;
+        /** Docker-specific sandbox settings. */
+        docker?: SandboxDockerSettings;
+        /** Optional sandboxed browser settings. */
+        browser?: SandboxBrowserSettings;
+        /** Auto-prune sandbox containers. */
+        prune?: SandboxPruneSettings;
+    };
+};
+export type AgentCompactionMode = "default" | "safeguard";
+export type AgentCompactionConfig = {
+    /** Compaction summarization mode. */
+    mode?: AgentCompactionMode;
+    /** Minimum reserve tokens enforced for Pi compaction (0 disables the floor). */
+    reserveTokensFloor?: number;
+    /** Max share of context window for history during safeguard pruning (0.1–0.9, default 0.5). */
+    maxHistoryShare?: number;
+    /** Pre-compaction memory flush (agentic turn). Default: enabled. */
+    memoryFlush?: AgentCompactionMemoryFlushConfig;
+};
+export type AgentCompactionMemoryFlushConfig = {
+    /** Enable the pre-compaction memory flush (default: true). */
+    enabled?: boolean;
+    /** Run the memory flush when context is within this many tokens of the compaction threshold. */
+    softThresholdTokens?: number;
+    /** User prompt used for the memory flush turn (NO_REPLY is enforced if missing). */
+    prompt?: string;
+    /** System prompt appended for the memory flush turn. */
+    systemPrompt?: string;
+};

package/dist/config/types.agents.d.ts

@@ -0,0 +1,75 @@
+import type { AgentDefaultsConfig } from "./types.agent-defaults.js";
+import type { HumanDelayConfig, IdentityConfig } from "./types.base.js";
+import type { GroupChatConfig } from "./types.messages.js";
+import type { SandboxBrowserSettings, SandboxDockerSettings, SandboxPruneSettings } from "./types.sandbox.js";
+import type { AgentToolsConfig, MemorySearchConfig } from "./types.tools.js";
+export type AgentModelConfig = string | {
+    /** Primary model (provider/model). */
+    primary?: string;
+    /** Per-agent model fallbacks (provider/model). */
+    fallbacks?: string[];
+};
+export type AgentConfig = {
+    id: string;
+    default?: boolean;
+    name?: string;
+    workspace?: string;
+    agentDir?: string;
+    model?: AgentModelConfig;
+    memorySearch?: MemorySearchConfig;
+    /** Human-like delay between block replies for this agent. */
+    humanDelay?: HumanDelayConfig;
+    /** Optional per-agent heartbeat overrides. */
+    heartbeat?: AgentDefaultsConfig["heartbeat"];
+    identity?: IdentityConfig;
+    groupChat?: GroupChatConfig;
+    subagents?: {
+        /** Allow spawning sub-agents under other agent ids. Use "*" to allow any. */
+        allowAgents?: string[];
+        /** Per-agent default model for spawned sub-agents (string or {primary,fallbacks}). */
+        model?: string | {
+            primary?: string;
+            fallbacks?: string[];
+        };
+    };
+    sandbox?: {
+        mode?: "off" | "non-main" | "all";
+        /** Agent workspace access inside the sandbox. */
+        workspaceAccess?: "none" | "ro" | "rw";
+        /**
+         * Session tools visibility for sandboxed sessions.
+         * - "spawned": only allow session tools to target sessions spawned from this session (default)
+         * - "all": allow session tools to target any session
+         */
+        sessionToolsVisibility?: "spawned" | "all";
+        /** Container/workspace scope for sandbox isolation. */
+        scope?: "session" | "agent" | "shared";
+        /** Legacy alias for scope ("session" when true, "shared" when false). */
+        perSession?: boolean;
+        workspaceRoot?: string;
+        /** Docker-specific sandbox overrides for this agent. */
+        docker?: SandboxDockerSettings;
+        /** Optional sandboxed browser overrides for this agent. */
+        browser?: SandboxBrowserSettings;
+        /** Auto-prune overrides for this agent. */
+        prune?: SandboxPruneSettings;
+    };
+    tools?: AgentToolsConfig;
+};
+export type AgentsConfig = {
+    defaults?: AgentDefaultsConfig;
+    list?: AgentConfig[];
+};
+export type AgentBinding = {
+    agentId: string;
+    match: {
+        channel: string;
+        accountId?: string;
+        peer?: {
+            kind: "dm" | "group" | "channel";
+            id: string;
+        };
+        guildId?: string;
+        teamId?: string;
+    };
+};

package/dist/config/types.approvals.d.ts

@@ -0,0 +1,26 @@
+export type ExecApprovalForwardingMode = "session" | "targets" | "both";
+export type ExecApprovalForwardTarget = {
+    /** Channel id (e.g. "discord", "slack", or plugin channel id). */
+    channel: string;
+    /** Destination id (channel id, user id, etc. depending on channel). */
+    to: string;
+    /** Optional account id for multi-account channels. */
+    accountId?: string;
+    /** Optional thread id to reply inside a thread. */
+    threadId?: string | number;
+};
+export type ExecApprovalForwardingConfig = {
+    /** Enable forwarding exec approvals to chat channels. Default: false. */
+    enabled?: boolean;
+    /** Delivery mode (session=origin chat, targets=config targets, both=both). Default: session. */
+    mode?: ExecApprovalForwardingMode;
+    /** Only forward approvals for these agent IDs. Omit = all agents. */
+    agentFilter?: string[];
+    /** Only forward approvals matching these session key patterns (substring or regex). */
+    sessionFilter?: string[];
+    /** Explicit delivery targets (used when mode includes targets). */
+    targets?: ExecApprovalForwardTarget[];
+};
+export type ApprovalsConfig = {
+    exec?: ExecApprovalForwardingConfig;
+};

package/dist/config/types.auth.d.ts

@@ -0,0 +1,28 @@
+export type AuthProfileConfig = {
+    provider: string;
+    /**
+     * Credential type expected in auth-profiles.json for this profile id.
+     * - api_key: static provider API key
+     * - oauth: refreshable OAuth credentials (access+refresh+expires)
+     * - token: static bearer-style token (optionally expiring; no refresh)
+     */
+    mode: "api_key" | "oauth" | "token";
+    email?: string;
+};
+export type AuthConfig = {
+    profiles?: Record<string, AuthProfileConfig>;
+    order?: Record<string, string[]>;
+    cooldowns?: {
+        /** Default billing backoff (hours). Default: 5. */
+        billingBackoffHours?: number;
+        /** Optional per-provider billing backoff (hours). */
+        billingBackoffHoursByProvider?: Record<string, number>;
+        /** Billing backoff cap (hours). Default: 24. */
+        billingMaxHours?: number;
+        /**
+         * Failure window for backoff counters (hours). If no failures occur within
+         * this window, counters reset. Default: 24.
+         */
+        failureWindowHours?: number;
+    };
+};

package/dist/config/types.base.d.ts

@@ -0,0 +1,149 @@
+import type { NormalizedChatType } from "../channels/chat-type.js";
+export type ReplyMode = "text" | "command";
+export type TypingMode = "never" | "instant" | "thinking" | "message";
+export type SessionScope = "per-sender" | "global";
+export type DmScope = "main" | "per-peer" | "per-channel-peer" | "per-account-channel-peer";
+export type ReplyToMode = "off" | "first" | "all";
+export type GroupPolicy = "open" | "disabled" | "allowlist";
+export type DmPolicy = "pairing" | "allowlist" | "open" | "disabled";
+export type OutboundRetryConfig = {
+    /** Max retry attempts for outbound requests (default: 3). */
+    attempts?: number;
+    /** Minimum retry delay in ms (default: 300-500ms depending on provider). */
+    minDelayMs?: number;
+    /** Maximum retry delay cap in ms (default: 30000). */
+    maxDelayMs?: number;
+    /** Jitter factor (0-1) applied to delays (default: 0.1). */
+    jitter?: number;
+};
+export type BlockStreamingCoalesceConfig = {
+    minChars?: number;
+    maxChars?: number;
+    idleMs?: number;
+};
+export type BlockStreamingChunkConfig = {
+    minChars?: number;
+    maxChars?: number;
+    breakPreference?: "paragraph" | "newline" | "sentence";
+};
+export type MarkdownTableMode = "off" | "bullets" | "code";
+export type MarkdownConfig = {
+    /** Table rendering mode (off|bullets|code). */
+    tables?: MarkdownTableMode;
+};
+export type HumanDelayConfig = {
+    /** Delay style for block replies (off|natural|custom). */
+    mode?: "off" | "natural" | "custom";
+    /** Minimum delay in milliseconds (default: 800). */
+    minMs?: number;
+    /** Maximum delay in milliseconds (default: 2500). */
+    maxMs?: number;
+};
+export type SessionSendPolicyAction = "allow" | "deny";
+export type SessionSendPolicyMatch = {
+    channel?: string;
+    chatType?: NormalizedChatType;
+    keyPrefix?: string;
+};
+export type SessionSendPolicyRule = {
+    action: SessionSendPolicyAction;
+    match?: SessionSendPolicyMatch;
+};
+export type SessionSendPolicyConfig = {
+    default?: SessionSendPolicyAction;
+    rules?: SessionSendPolicyRule[];
+};
+export type SessionResetMode = "daily" | "idle";
+export type SessionResetConfig = {
+    mode?: SessionResetMode;
+    /** Local hour (0-23) for the daily reset boundary. */
+    atHour?: number;
+    /** Sliding idle window (minutes). When set with daily mode, whichever expires first wins. */
+    idleMinutes?: number;
+};
+export type SessionResetByTypeConfig = {
+    dm?: SessionResetConfig;
+    group?: SessionResetConfig;
+    thread?: SessionResetConfig;
+};
+export type SessionConfig = {
+    scope?: SessionScope;
+    /** DM session scoping (default: "main"). */
+    dmScope?: DmScope;
+    /** Map platform-prefixed identities (e.g. "telegram:123") to canonical DM peers. */
+    identityLinks?: Record<string, string[]>;
+    resetTriggers?: string[];
+    idleMinutes?: number;
+    reset?: SessionResetConfig;
+    resetByType?: SessionResetByTypeConfig;
+    /** Channel-specific reset overrides (e.g. { discord: { mode: "idle", idleMinutes: 10080 } }). */
+    resetByChannel?: Record<string, SessionResetConfig>;
+    store?: string;
+    typingIntervalSeconds?: number;
+    typingMode?: TypingMode;
+    mainKey?: string;
+    sendPolicy?: SessionSendPolicyConfig;
+    agentToAgent?: {
+        /** Max ping-pong turns between requester/target (0–5). Default: 5. */
+        maxPingPongTurns?: number;
+    };
+};
+export type LoggingConfig = {
+    level?: "silent" | "fatal" | "error" | "warn" | "info" | "debug" | "trace";
+    file?: string;
+    consoleLevel?: "silent" | "fatal" | "error" | "warn" | "info" | "debug" | "trace";
+    consoleStyle?: "pretty" | "compact" | "json";
+    /** Redact sensitive tokens in tool summaries. Default: "tools". */
+    redactSensitive?: "off" | "tools";
+    /** Regex patterns used to redact sensitive tokens (defaults apply when unset). */
+    redactPatterns?: string[];
+};
+export type DiagnosticsOtelConfig = {
+    enabled?: boolean;
+    endpoint?: string;
+    protocol?: "http/protobuf" | "grpc";
+    headers?: Record<string, string>;
+    serviceName?: string;
+    traces?: boolean;
+    metrics?: boolean;
+    logs?: boolean;
+    /** Trace sample rate (0.0 - 1.0). */
+    sampleRate?: number;
+    /** Metric export interval (ms). */
+    flushIntervalMs?: number;
+};
+export type DiagnosticsCacheTraceConfig = {
+    enabled?: boolean;
+    filePath?: string;
+    includeMessages?: boolean;
+    includePrompt?: boolean;
+    includeSystem?: boolean;
+};
+export type DiagnosticsConfig = {
+    enabled?: boolean;
+    /** Optional ad-hoc diagnostics flags (e.g. "telegram.http"). */
+    flags?: string[];
+    otel?: DiagnosticsOtelConfig;
+    cacheTrace?: DiagnosticsCacheTraceConfig;
+};
+export type WebReconnectConfig = {
+    initialMs?: number;
+    maxMs?: number;
+    factor?: number;
+    jitter?: number;
+    maxAttempts?: number;
+};
+export type WebConfig = {
+    /** If false, do not start the WhatsApp web provider. Default: true. */
+    enabled?: boolean;
+    heartbeatSeconds?: number;
+    reconnect?: WebReconnectConfig;
+};
+export type AgentElevatedAllowFromConfig = Partial<Record<string, Array<string | number>>>;
+export type IdentityConfig = {
+    name?: string;
+    theme?: string;
+    emoji?: string;
+    /** Avatar image: workspace-relative path, http(s) URL, or data URI. */
+    avatar?: string;
+};

package/dist/config/types.browser.d.ts

@@ -0,0 +1,41 @@
+export type BrowserProfileConfig = {
+    /** CDP port for this profile. Allocated once at creation, persisted permanently. */
+    cdpPort?: number;
+    /** CDP URL for this profile (use for remote Chrome). */
+    cdpUrl?: string;
+    /** Profile driver (default: openclaw). */
+    driver?: "openclaw" | "extension";
+    /** Profile color (hex). Auto-assigned at creation. */
+    color: string;
+};
+export type BrowserSnapshotDefaults = {
+    /** Default snapshot mode (applies when mode is not provided). */
+    mode?: "efficient";
+};
+export type BrowserConfig = {
+    enabled?: boolean;
+    /** If false, disable browser act:evaluate (arbitrary JS). Default: true */
+    evaluateEnabled?: boolean;
+    /** Base URL of the CDP endpoint (for remote browsers). Default: loopback CDP on the derived port. */
+    cdpUrl?: string;
+    /** Remote CDP HTTP timeout (ms). Default: 1500. */
+    remoteCdpTimeoutMs?: number;
+    /** Remote CDP WebSocket handshake timeout (ms). Default: max(remoteCdpTimeoutMs * 2, 2000). */
+    remoteCdpHandshakeTimeoutMs?: number;
+    /** Accent color for the openclaw browser profile (hex). Default: #FF4500 */
+    color?: string;
+    /** Override the browser executable path (all platforms). */
+    executablePath?: string;
+    /** Start Chrome headless (best-effort). Default: false */
+    headless?: boolean;
+    /** Pass --no-sandbox to Chrome (Linux containers). Default: false */
+    noSandbox?: boolean;
+    /** If true: never launch; only attach to an existing browser. Default: false */
+    attachOnly?: boolean;
+    /** Default profile to use when profile param is omitted. Default: "chrome" */
+    defaultProfile?: string;
+    /** Named browser profiles with explicit CDP ports or URLs. */
+    profiles?: Record<string, BrowserProfileConfig>;
+    /** Default snapshot options (applied by the browser tool/CLI when unset). */
+    snapshotDefaults?: BrowserSnapshotDefaults;
+};

package/dist/config/types.channels.d.ts

@@ -0,0 +1,34 @@
+import type { GroupPolicy } from "./types.base.js";
+import type { DiscordConfig } from "./types.discord.js";
+import type { GoogleChatConfig } from "./types.googlechat.js";
+import type { IMessageConfig } from "./types.imessage.js";
+import type { MSTeamsConfig } from "./types.msteams.js";
+import type { SignalConfig } from "./types.signal.js";
+import type { SlackConfig } from "./types.slack.js";
+import type { TelegramConfig } from "./types.telegram.js";
+import type { WhatsAppConfig } from "./types.whatsapp.js";
+export type ChannelHeartbeatVisibilityConfig = {
+    /** Show HEARTBEAT_OK acknowledgments in chat (default: false). */
+    showOk?: boolean;
+    /** Show heartbeat alerts with actual content (default: true). */
+    showAlerts?: boolean;
+    /** Emit indicator events for UI status display (default: true). */
+    useIndicator?: boolean;
+};
+export type ChannelDefaultsConfig = {
+    groupPolicy?: GroupPolicy;
+    /** Default heartbeat visibility for all channels. */
+    heartbeat?: ChannelHeartbeatVisibilityConfig;
+};
+export type ChannelsConfig = {
+    defaults?: ChannelDefaultsConfig;
+    whatsapp?: WhatsAppConfig;
+    telegram?: TelegramConfig;
+    discord?: DiscordConfig;
+    googlechat?: GoogleChatConfig;
+    slack?: SlackConfig;
+    signal?: SignalConfig;
+    imessage?: IMessageConfig;
+    msteams?: MSTeamsConfig;
+    [key: string]: unknown;
+};