@aspalagin/openclaw-max 0.7.2 → 0.8.0

package/dist/src/channel-outbound.js

@@ -2,14 +2,31 @@
  * Outbound adapter of the MAX channel: sendText / sendPayload / sendMedia,
  * presentation rendering and delivery pins for core's outbound path.
  */
+import { getAgentScopedMediaLocalRoots } from 'openclaw/plugin-sdk/media-local-roots';
 import { resolveMaxAccount } from './accounts.js';
-import { materializeMaxPresentation, MAX_PRESENTATION_CAPABILITIES, MAX_TEXT_LIMIT, renderMaxPresentation, } from './presentation.js';
+import { materializeMaxPresentation, MAX_PRESENTATION_CAPABILITIES, MAX_TEXT_LIMIT, renderMaxPresentation, resolveMaxTextChunkLimit, } from './presentation.js';
 import { getMaxRuntime, loadMaxConfig } from './runtime.js';
-import { pinMaxMessage, readMaxChannelButtons, sendMaxMediaGroup, sendMaxMediaMessage, sendMaxMessage, } from './send.js';
-/** Direct delivery with 4000-character markdown chunks. */
+import { pinMaxMessage, readMaxChannelButtons, resolveMaxSendFlags, sendMaxMediaGroup, sendMaxMediaMessage, sendMaxMessage, } from './send.js';
+/**
+ * Local media access for an outbound send: the roots and host reader core
+ * passed with the delivery; without them the default media roots (no agent
+ * workspace is known here). Local files are read only through this policy.
+ */
+function resolveOutboundLocalMedia(cfg, ctx) {
+    if (ctx.mediaAccess || ctx.mediaLocalRoots?.length || ctx.mediaReadFile) {
+        return {
+            mediaAccess: ctx.mediaAccess,
+            mediaLocalRoots: ctx.mediaLocalRoots,
+            mediaReadFile: ctx.mediaReadFile,
+        };
+    }
+    return { mediaLocalRoots: getAgentScopedMediaLocalRoots(cfg) };
+}
+/** Direct delivery with markdown chunks of at most 4000 characters. */
 export const maxOutboundAdapter = {
     deliveryMode: 'direct',
-    chunker: (text, limit) => getMaxRuntime().channel.text.chunkMarkdownText(text, limit),
+    // Core passes channels.max.textChunkLimit here; MAX rejects anything longer than 4000.
+    chunker: (text, limit) => getMaxRuntime().channel.text.chunkMarkdownText(text, Math.min(limit, MAX_TEXT_LIMIT)),
     chunkerMode: 'markdown',
     textChunkLimit: 4000,
     // Presentation (docs/plugins/message-presentation.md): core adapts to these
@@ -31,7 +48,8 @@ export const maxOutboundAdapter = {
             beforeRequest: assertDirectAdapterHandoff,
         });
     },
-    sendPayload: async ({ to, text, payload: rawPayload, mediaUrl, accountId, replyToId }) => {
+    sendPayload: async (ctx) => {
+        const { to, text, payload: rawPayload, mediaUrl, accountId, replyToId } = ctx;
         const cfg = await loadMaxConfig();
         const account = resolveMaxAccount({ cfg, accountId });
         if (!account.token)
@@ -43,6 +61,10 @@ export const maxOutboundAdapter = {
             : rawPayload;
         const effectiveText = payload === rawPayload ? text : (payload.text ?? '');
         const buttons = readMaxChannelButtons(payload.channelData);
+        const sendFlags = resolveMaxSendFlags(account.config, {
+            silent: ctx.silent,
+            channelData: payload.channelData,
+        });
         const mediaUrls = mediaUrl
             ? [mediaUrl]
             : payload.mediaUrls?.length
@@ -58,7 +80,10 @@ export const maxOutboundAdapter = {
                 replyToMessageId: replyToId ?? undefined,
                 format: 'markdown',
                 buttons,
+                ...sendFlags,
                 mediaMaxBytes: (account.config.mediaMaxMb ?? 20) * 1024 * 1024,
+                localMedia: resolveOutboundLocalMedia(cfg, ctx),
+                asVoice: ctx.audioAsVoice === true || payload.audioAsVoice === true,
             });
             return {
                 channel: 'max',
@@ -67,8 +92,9 @@ export const maxOutboundAdapter = {
         }
         // MAX caps a message at 4000 characters: split, keyboard on the last
         // chunk, report the first one (delivery.pin pins the first chunk).
-        const chunks = effectiveText.length > MAX_TEXT_LIMIT
-            ? getMaxRuntime().channel.text.chunkMarkdownText(effectiveText, MAX_TEXT_LIMIT)
+        const chunkLimit = resolveMaxTextChunkLimit(cfg, account.accountId);
+        const chunks = effectiveText.length > chunkLimit
+            ? getMaxRuntime().channel.text.chunkMarkdownText(effectiveText, chunkLimit)
             : [effectiveText];
         let firstMessageId = '';
         for (let index = 0; index < chunks.length; index += 1) {
@@ -77,6 +103,7 @@ export const maxOutboundAdapter = {
                 replyToMessageId: index === 0 ? (replyToId ?? undefined) : undefined,
                 format: 'markdown',
                 buttons: index === chunks.length - 1 ? buttons : undefined,
+                ...sendFlags,
             });
             if (index === 0)
                 firstMessageId = result.messageId;
@@ -86,7 +113,7 @@ export const maxOutboundAdapter = {
             messageId: firstMessageId,
         };
     },
-    sendText: async ({ to, text, accountId, replyToId }) => {
+    sendText: async ({ to, text, accountId, replyToId, silent }) => {
         const cfg = await loadMaxConfig();
         const account = resolveMaxAccount({ cfg, accountId });
         if (!account.token)
@@ -95,23 +122,27 @@ export const maxOutboundAdapter = {
             token: account.token,
             replyToMessageId: replyToId ?? undefined,
             format: 'markdown',
+            ...resolveMaxSendFlags(account.config, { silent }),
         });
         return {
             channel: 'max',
             messageId: result.messageId,
         };
     },
-    sendMedia: async ({ to, text, mediaUrl, accountId, replyToId }) => {
+    sendMedia: async (ctx) => {
+        const { to, text, mediaUrl, accountId, replyToId } = ctx;
         const cfg = await loadMaxConfig();
         const account = resolveMaxAccount({ cfg, accountId });
         if (!account.token)
             throw new Error('MAX bot token not configured');
+        const sendFlags = resolveMaxSendFlags(account.config, { silent: ctx.silent });
         if (!mediaUrl) {
             // No media, send as text
             const result = await sendMaxMessage(to, text, {
                 token: account.token,
                 replyToMessageId: replyToId ?? undefined,
                 format: 'markdown',
+                ...sendFlags,
             });
             return {
                 channel: 'max',
@@ -123,7 +154,10 @@ export const maxOutboundAdapter = {
             token: account.token,
             replyToMessageId: replyToId ?? undefined,
             format: 'markdown',
+            ...sendFlags,
             mediaMaxBytes: (account.config.mediaMaxMb ?? 20) * 1024 * 1024,
+            localMedia: resolveOutboundLocalMedia(cfg, ctx),
+            asVoice: ctx.audioAsVoice === true,
         });
         return {
             channel: 'max',

package/dist/src/channel.js

@@ -18,6 +18,8 @@ import { maxGroupsAdapter, maxPairingAdapter, maxSecurityAdapter } from './chann
 import { MaxConfigSchema } from './config-schema.js';
 import { buildMaxModelBrowseChannelData, buildMaxModelsAddProviderChannelData, buildMaxModelsListChannelData, buildMaxModelsMenuChannelData, buildMaxModelsProviderChannelData, } from './model-buttons.js';
 import { maxSetupWizard } from './onboarding.js';
+import { maxChannelSecrets } from './secret-contract.js';
+import { sendMaxHeartbeatTyping } from './typing.js';
 // ── Meta ──
 const maxMeta = {
     id: 'max',
@@ -46,6 +48,16 @@ export const maxPlugin = {
         unsend: true,
         reply: true,
         polls: false,
+        // TTS replies: core keeps its normal audio-file synthesis (MP3 unless the
+        // provider is set otherwise) and marks audio in these formats as voice.
+        // MAX documents MP3/WAV/M4A for audio and records its own voice messages
+        // as Ogg/Opus; no transcoding on either side.
+        tts: {
+            voice: {
+                synthesisTarget: 'audio-file',
+                audioFileFormats: ['mp3', 'm4a', 'wav', 'ogg', 'opus'],
+            },
+        },
     },
     reload: { configPrefixes: ['channels.max'] },
     commands: {
@@ -69,8 +81,12 @@ export const maxPlugin = {
     directory: maxDirectoryAdapter,
     outbound: maxOutboundAdapter,
     setup: maxSetupAdapter,
+    // botToken, webhookSecret, httpProxy accept SecretRefs (also exported as
+    // dist/secret-contract-api.js for the gateway's pre-runtime resolution).
+    secrets: maxChannelSecrets,
     status: maxStatusAdapter,
     gateway: maxGatewayAdapter,
+    heartbeat: { sendTyping: sendMaxHeartbeatTyping, sendTypingGuarded: sendMaxHeartbeatTyping },
     // Message actions (send, edit, delete)
     actions: maxMessageActions,
 };

package/dist/src/command-menu.js

@@ -0,0 +1,199 @@
+/**
+ * Argument menus for core commands. A bare command whose core definition
+ * declares an argument menu (argsMenu: /think, /fast, /reasoning, /verbose,
+ * /usage, /tts, …) gets its choices as buttons; a press re-enters the inbound
+ * pipeline as that command's text, so it is applied exactly like typing it.
+ *
+ * Choices, titles and command text come from the core command registry;
+ * session state is only read through the runtime session API. Nothing here
+ * changes the session or the config: the chosen command does, in core.
+ */
+import { buildCommandTextFromArgs, findCommandByNativeName, formatCommandArgMenuTitle, formatFastModeCurrentStatus, listChatCommands, normalizeCommandBody, parseCommandArgs, resolveCommandArgChoices, resolveCommandArgMenu, resolveCommandAuthorization, resolveEffectiveAgentRuntime, resolveFastModeState, resolveStoredModelOverride, } from 'openclaw/plugin-sdk/command-auth-native';
+import { MAX_CALLBACK_PAYLOAD_BYTES } from './presentation.js';
+import { getMaxRuntime } from './runtime.js';
+/** Private envelope of a menu button: the command text of one choice. */
+const COMMAND_MENU_PREFIX = 'mxcmd1:';
+/** Session fields whose stored value is one of the command's choice values. */
+const SESSION_CHOICE_FIELDS = {
+    think: 'thinkingLevel',
+    verbose: 'verboseLevel',
+    reasoning: 'reasoningLevel',
+    elevated: 'elevatedLevel',
+    trace: 'traceLevel',
+    usage: 'responseUsage',
+    activation: 'groupActivation',
+};
+export function encodeMaxCommandMenuPayload(commandText) {
+    const payload = `${COMMAND_MENU_PREFIX}${commandText}`;
+    return Buffer.byteLength(payload, 'utf8') <= MAX_CALLBACK_PAYLOAD_BYTES ? payload : null;
+}
+/** Command text of a menu button press; null for any other payload. */
+export function decodeMaxCommandMenuPayload(payload) {
+    if (!payload?.startsWith(COMMAND_MENU_PREFIX))
+        return null;
+    const text = payload.slice(COMMAND_MENU_PREFIX.length).trim();
+    return text.startsWith('/') ? text : null;
+}
+/** A slash command whose core definition has an argument menu; null otherwise. */
+function parseMenuCommand(text, botUsername) {
+    const normalized = normalizeCommandBody(text.trim(), botUsername ? { botUsername } : undefined);
+    const match = /^\/(\S+)(?:\s+([\s\S]*))?$/u.exec(normalized);
+    if (!match)
+        return null;
+    const name = match[1].toLowerCase();
+    const command = findCommandByNativeName(name, 'max') ??
+        listChatCommands().find((entry) => entry.key === name || entry.textAliases.includes(`/${name}`));
+    if (!command?.args?.length || !command.argsMenu)
+        return null;
+    return { command, args: parseCommandArgs(command, match[2]?.trim() || undefined) };
+}
+/** The session's model (dynamic choices such as /think levels depend on it). */
+function resolveMenuModelContext(params) {
+    const core = getMaxRuntime();
+    const { cfg, agentId, sessionKey } = params;
+    try {
+        const load = (key) => core.agent.session.getSessionEntry({ agentId, sessionKey: key });
+        const entry = load(sessionKey);
+        const defaults = core.modelConfig.resolveDefaultModelForAgent({ cfg, agentId });
+        // An automatic fallback override is temporary: menus follow the default.
+        const override = entry?.modelOverrideSource === 'auto'
+            ? null
+            : resolveStoredModelOverride({
+                sessionEntry: entry,
+                loadSessionEntry: load,
+                sessionKey,
+                defaultProvider: defaults.provider,
+            });
+        const provider = override?.provider ?? defaults.provider;
+        const model = override?.model ?? defaults.model;
+        let agentRuntime;
+        try {
+            agentRuntime = resolveEffectiveAgentRuntime({
+                cfg,
+                provider,
+                modelId: model,
+                agentId,
+                sessionKey,
+                sessionEntry: entry,
+            });
+        }
+        catch {
+            agentRuntime = undefined;
+        }
+        return { entry, provider, model, agentRuntime };
+    }
+    catch {
+        return {};
+    }
+}
+/** Every argument value of a pressed command is still among core's choices. */
+function isPressStillOffered(command, args, cfg, context) {
+    const values = args?.values ?? {};
+    for (const arg of command.args ?? []) {
+        const value = values[arg.name];
+        if (value == null || !arg.choices)
+            continue;
+        const choices = resolveCommandArgChoices({
+            command,
+            arg,
+            cfg,
+            provider: context.provider,
+            model: context.model,
+            agentRuntime: context.agentRuntime,
+        });
+        if (choices.length > 0 && !choices.some((choice) => choice.value === String(value))) {
+            return false;
+        }
+    }
+    return true;
+}
+function resolveCurrentChoice(command, context, fastState) {
+    if (fastState) {
+        if (fastState.source !== 'session')
+            return 'default';
+        return fastState.mode === 'auto' ? 'auto' : fastState.mode ? 'on' : 'off';
+    }
+    const field = SESSION_CHOICE_FIELDS[command.key];
+    const stored = field ? context.entry?.[field] : undefined;
+    if (typeof stored === 'string' && stored)
+        return stored;
+    // Nothing stored for this session: the "default" choice is what applies.
+    return 'default';
+}
+/**
+ * Decide what a slash command (typed, or pressed on a menu when `press`) does:
+ * open its argument menu, go to core unchanged, or — presses only — be refused
+ * for lack of command rights or as stale. `ctx` is the finalized inbound
+ * context of the message, so command rights are resolved exactly as core
+ * resolves them for the same text.
+ */
+export function resolveMaxCommandMenu(params) {
+    const { press, cfg, agentId, sessionKey } = params;
+    const pass = press ? { kind: 'stale' } : { kind: 'dispatch' };
+    const parsed = parseMenuCommand(params.text, params.botUsername);
+    if (!parsed)
+        return pass;
+    const { command, args } = parsed;
+    const core = getMaxRuntime();
+    if (!core.channel.commands.shouldHandleTextCommands({ cfg, surface: 'max', commandSource: 'text' })) {
+        return pass;
+    }
+    // Core authorizes MAX text commands with CommandAuthorized unset (false).
+    const authorization = resolveCommandAuthorization({
+        ctx: params.ctx,
+        cfg,
+        commandAuthorized: params.ctx.CommandAuthorized === true,
+    });
+    if (!authorization.isAuthorizedSender) {
+        return press ? { kind: 'denied' } : { kind: 'dispatch' };
+    }
+    const context = resolveMenuModelContext({ cfg, agentId, sessionKey });
+    if (press && !isPressStillOffered(command, args, cfg, context))
+        return { kind: 'stale' };
+    const menu = resolveCommandArgMenu({
+        command,
+        args,
+        cfg,
+        provider: context.provider,
+        model: context.model,
+        agentRuntime: context.agentRuntime,
+        session: { agentId, sessionKey },
+    });
+    if (!menu)
+        return { kind: 'dispatch' };
+    const fastState = command.key === 'fast' && context.provider && context.model
+        ? resolveFastModeState({
+            cfg,
+            provider: context.provider,
+            model: context.model,
+            agentId,
+            sessionEntry: context.entry?.fastMode !== undefined
+                ? { fastMode: context.entry.fastMode }
+                : undefined,
+        })
+        : undefined;
+    const current = resolveCurrentChoice(command, context, fastState);
+    let title = formatCommandArgMenuTitle({ command, menu });
+    if (fastState) {
+        title = `${formatFastModeCurrentStatus(fastState)}\n${title}`;
+    }
+    else if (command.key === 'think' && current !== 'default') {
+        title = `Current thinking level: ${current}.\n${title}`;
+    }
+    const buttons = [];
+    for (const choice of menu.choices) {
+        const payload = encodeMaxCommandMenuPayload(buildCommandTextFromArgs(command, {
+            values: { ...args?.values, [menu.arg.name]: choice.value },
+        }));
+        if (!payload)
+            continue;
+        buttons.push({ text: choice.value === current ? `${choice.label} ✓` : choice.label, payload });
+    }
+    if (buttons.length === 0)
+        return { kind: 'dispatch' };
+    const rows = [];
+    for (let index = 0; index < buttons.length; index += 2) {
+        rows.push(buttons.slice(index, index + 2));
+    }
+    return { kind: 'menu', text: title, buttons: rows };
+}

package/dist/src/config-schema.js

@@ -1,12 +1,18 @@
 /**
  * MAX channel config Zod schema
  */
-import { MarkdownConfigSchema, ToolPolicySchema } from 'openclaw/plugin-sdk/channel-config-schema';
+import { ChannelPreviewStreamingConfigSchema, MarkdownConfigSchema, MentionPatternsPolicySchema, ToolPolicySchema, } from 'openclaw/plugin-sdk/channel-config-schema';
+import { buildOptionalSecretInputSchema } from 'openclaw/plugin-sdk/secret-input';
 import { z } from 'zod';
-// Defaulted policy fields are built with this package's own zod: wrapping the
-// SDK's enum instances in `.optional().default()` breaks as soon as the plugin
-// and the gateway resolve different zod copies (4.4 vs 4.6 → "expected
-// nonoptional"). Values mirror the SDK's DmPolicySchema/GroupPolicySchema.
+// Policy fields are built with this package's own zod: wrapping the SDK's enum
+// instances in `.optional().default()` broke as soon as the plugin and the
+// gateway resolved different zod copies (4.4 vs 4.6 → "expected nonoptional").
+// Values mirror the SDK's DmPolicySchema/GroupPolicySchema.
+//
+// No field carries a schema default: the gateway writes JSON-schema defaults
+// into the runtime config, also under accounts.<id>, and a default there would
+// hide the channel-level value a named account inherits. The effective
+// defaults (pairing, allowlist, …) are applied where the values are read.
 export const DmPolicySchema = z.enum(['pairing', 'allowlist', 'open', 'disabled']);
 export const GroupPolicySchema = z.enum(['open', 'disabled', 'allowlist']);
 // These schemas were removed from the public plugin-sdk surface in OpenClaw 2026.3.x.
@@ -42,45 +48,133 @@ export const MaxGroupSchema = z
     .object({
     requireMention: z.boolean().optional(),
     tools: ToolPolicySchema.optional(),
+    /** Skills a group turn may load (core skillFilter; [] = none). */
     skills: z.array(z.string()).optional(),
+    /** false: the group is ignored under any groupPolicy. */
     enabled: z.boolean().optional(),
     allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    /** Extra system prompt of group turns (core GroupSystemPrompt). */
     systemPrompt: z.string().optional(),
+    /** Skip transcribing a captionless voice message to find a mention pattern. */
+    disableAudioPreflight: z.boolean().optional(),
 })
     .strict();
 /**
- * MAX account config (base schema for both top-level and accounts.*)
+ * MAX account config (base schema for both top-level and accounts.*).
+ * accounts.<id> inherits every channel-level value it does not set, except
+ * the per-bot keys (token, name, webhook; MAX_ACCOUNT_OWN_KEYS in accounts.ts).
  */
 export const MaxAccountSchemaBase = z
     .object({
     name: z.string().optional(),
     enabled: z.boolean().optional(),
+    /** No effect in MAX: neither the plugin nor core reads it for this channel. */
     markdown: MarkdownConfigSchema.optional(),
-    botToken: z.string().optional(),
+    /** Plain token or a core SecretRef { source, provider, id } (also webhookSecret, httpProxy) */
+    botToken: buildOptionalSecretInputSchema(),
     tokenFile: z.string().optional(),
-    dmPolicy: DmPolicySchema.optional().default('pairing'),
+    /** Default "pairing" (applied where read); named accounts inherit the channel value. */
+    dmPolicy: DmPolicySchema.optional(),
     allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
     groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-    groupPolicy: GroupPolicySchema.optional().default('allowlist'),
+    /** Default "allowlist" (applied where read); named accounts inherit the channel value. */
+    groupPolicy: GroupPolicySchema.optional(),
     groups: z.record(z.string(), MaxGroupSchema.optional()).optional(),
+    /**
+     * Where core mention patterns (messages.groupChat / agent groupChat
+     * mentionPatterns) apply in MAX groups: mode allow|deny, allowIn, denyIn.
+     */
+    mentionPatterns: MentionPatternsPolicySchema.optional(),
     /** Update transport; default: "webhook" when webhookUrl is set, otherwise "polling" */
     transport: z.enum(['polling', 'webhook']).optional(),
     webhookUrl: z.string().optional(),
     /** MAX secret: 5–256 of [A-Za-z0-9_-]; checked at start */
-    webhookSecret: z.string().optional(),
+    webhookSecret: buildOptionalSecretInputSchema(),
     /** File holding the webhook secret (regular file, not a symlink) */
     webhookSecretFile: z.string().optional(),
     webhookPath: z.string().optional(),
+    /**
+     * Webhook queue: "durable" (default) journals every accepted update before
+     * MAX gets its 200, so a restart or crash does not lose it; "memory" keeps
+     * the 0.7 in-memory queue. maxPending (default 5000) bounds accepted but
+     * unhandled updates; when full, overflow "reject" (default) answers 503
+     * so MAX redelivers later, "drop" acknowledges and drops.
+     */
+    webhookQueue: z
+        .object({
+        mode: z.enum(['durable', 'memory']).optional(),
+        maxPending: z.number().int().positive().optional(),
+        overflow: z.enum(['reject', 'drop']).optional(),
+    })
+        .strict()
+        .optional(),
+    /**
+     * Messages, edits, button presses and bot_started older than this many
+     * minutes (by MAX event time) are skipped instead of answered: after a
+     * long outage the bot does not reply to hours-old messages. Default 60;
+     * 0 answers any age.
+     */
+    maxEventAgeMinutes: z.number().int().min(0).optional(),
+    /**
+     * Debug logs of inbound messages carry a text preview (50 characters).
+     * Off by default: logs hold message type, length and ids, never text.
+     */
+    logMessagePreview: z.boolean().optional(),
+    /**
+     * Read by core, not the plugin: the embedded agent runtime keeps this many
+     * recent turns of a group session (historyLimit) or DM session
+     * (dmHistoryLimit, dms.<peer>.historyLimit) in the prompt.
+     */
     historyLimit: z.number().int().min(0).optional(),
     dmHistoryLimit: z.number().int().min(0).optional(),
     dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
+    /** Characters per outgoing message (core resolution), at most MAX's 4000. */
     textChunkLimit: z.number().int().positive().optional(),
+    /** No effect in MAX: use streamMode / streaming.mode "block". */
     blockStreaming: z.boolean().optional(),
     streamMode: z.enum(['off', 'partial', 'block']).optional(),
+    /**
+     * Core streaming settings; streaming.mode wins over streamMode. "progress"
+     * shows one turn-status message (streaming.progress: label, toolProgress,
+     * maxLines, …) that is deleted once the answer landed. Default off.
+     */
+    streaming: ChannelPreviewStreamingConfigSchema.optional(),
+    /** No effect in MAX: core reads streaming.block.coalesce instead. */
     blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
+    /** Prefix of agent replies, applied by core ("auto" = agent name). */
     responsePrefix: z.string().optional(),
     mediaMaxMb: z.number().positive().optional(),
+    /** Most media attachments downloaded per inbound message (default 12); the rest is noted. */
+    mediaMaxCount: z.number().int().positive().optional(),
     markSeen: z.boolean().optional(),
+    /**
+     * Chats message-tool actions may act in: "admitted" (default) — the current
+     * chat, owner requests and chats admitted by the DM/group policy;
+     * "current" — non-owner turns only in their own chat; "off" — no check.
+     */
+    actionScope: z.enum(['admitted', 'current', 'off']).optional(),
+    /**
+     * Send defaults; an explicit value of the call (core `silent`,
+     * channelData.max) wins. notify=false sends without push notifications
+     * (channels always notify).
+     */
+    notify: z.boolean().optional(),
+    disableLinkPreview: z.boolean().optional(),
+    /**
+     * MAX Bot API base URL (default https://platform-api2.max.ru), e.g. a test
+     * stand; https only, http just for loopback hosts. Checked at start.
+     */
+    apiBaseUrl: z.string().optional(),
+    /**
+     * HTTP(S) proxy for all MAX traffic of the account (API, uploads, media
+     * downloads), e.g. http://user:pass@host:3128; "" turns an inherited one
+     * off. Sensitive: credentials are never logged. Accepts a SecretRef.
+     */
+    httpProxy: buildOptionalSecretInputSchema(),
+    /**
+     * Message-tool actions: false turns one off (hidden from the tool and
+     * refused). Other values, including the legacy policy strings, leave it on.
+     */
     actions: z
         .record(z.string(), z.union([z.boolean(), z.enum(['pairing', 'allowlist', 'open'])]).optional())
         .optional(),
@@ -121,6 +215,8 @@ const MaxBotCommandSchema = z
 export const MaxConfigSchema = MaxAccountSchemaBase.extend({
     accounts: z.record(z.string(), MaxAccountSchema.optional()).optional(),
     commands: z.array(MaxBotCommandSchema).max(32).optional(),
+    /** Accepted as in the manifest; the channel-level options are always the "default" account. */
+    defaultAccount: z.string().optional(),
 }).superRefine((value, ctx) => {
     requireOpenAllowFrom({
         policy: value.dmPolicy,