@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/config/zod-schema.providers-core.js

@@ -1,9 +1,16 @@
 import { z } from "zod";
-import { BlockStreamingChunkSchema, BlockStreamingCoalesceSchema, DmConfigSchema, DmPolicySchema, ExecutableTokenSchema, GroupPolicySchema, MarkdownConfigSchema, MSTeamsReplyStyleSchema, ProviderCommandsSchema, ReplyToModeSchema, RetryConfigSchema, requireOpenAllowFrom, } from "./zod-schema.core.js";
+import { normalizeTelegramCommandDescription, normalizeTelegramCommandName, resolveTelegramCustomCommands, } from "./telegram-custom-commands.js";
 import { ToolPolicySchema } from "./zod-schema.agent-runtime.js";
 import { ChannelHeartbeatVisibilitySchema } from "./zod-schema.channels.js";
-import { normalizeTelegramCommandDescription, normalizeTelegramCommandName, resolveTelegramCustomCommands, } from "./telegram-custom-commands.js";
+import { BlockStreamingChunkSchema, BlockStreamingCoalesceSchema, DmConfigSchema, DmPolicySchema, ExecutableTokenSchema, GroupPolicySchema, HexColorSchema, MarkdownConfigSchema, MSTeamsReplyStyleSchema, ProviderCommandsSchema, ReplyToModeSchema, RetryConfigSchema, requireOpenAllowFrom, } from "./zod-schema.core.js";
+import { sensitive } from "./zod-schema.sensitive.js";
 const ToolPolicyBySenderSchema = z.record(z.string(), ToolPolicySchema).optional();
+const DiscordIdSchema = z
+    .union([z.string(), z.number()])
+    .refine((value) => typeof value === "string", {
+    message: "Discord IDs must be strings (wrap numeric IDs in quotes).",
+});
+const DiscordIdListSchema = z.array(DiscordIdSchema);
 const TelegramInlineButtonsScopeSchema = z.enum(["off", "dm", "group", "all", "allowlist"]);
 const TelegramCapabilitiesSchema = z.union([
     z.array(z.string()),
@@ -16,6 +23,7 @@ const TelegramCapabilitiesSchema = z.union([
 export const TelegramTopicSchema = z
     .object({
     requireMention: z.boolean().optional(),
+    groupPolicy: GroupPolicySchema.optional(),
     skills: z.array(z.string()).optional(),
     enabled: z.boolean().optional(),
     allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
@@ -42,8 +50,9 @@ const TelegramCustomCommandSchema = z
 })
     .strict();
 const validateTelegramCustomCommands = (value, ctx) => {
-    if (!value.customCommands || value.customCommands.length === 0)
+    if (!value.customCommands || value.customCommands.length === 0) {
         return;
+    }
     const { issues } = resolveTelegramCustomCommands({
         commands: value.customCommands,
         checkReserved: false,
@@ -67,7 +76,7 @@ export const TelegramAccountSchemaBase = z
     customCommands: z.array(TelegramCustomCommandSchema).optional(),
     configWrites: z.boolean().optional(),
     dmPolicy: DmPolicySchema.optional().default("pairing"),
-    botToken: z.string().optional(),
+    botToken: z.string().optional().register(sensitive),
     tokenFile: z.string().optional(),
     replyToMode: ReplyToModeSchema.optional(),
     groups: z.record(z.string(), TelegramGroupSchema.optional()).optional(),
@@ -94,8 +103,9 @@ export const TelegramAccountSchemaBase = z
         .optional(),
     proxy: z.string().optional(),
     webhookUrl: z.string().optional(),
-    webhookSecret: z.string().optional(),
+    webhookSecret: z.string().optional().register(sensitive),
     webhookPath: z.string().optional(),
+    webhookHost: z.string().optional(),
     actions: z
         .object({
         reactions: z.boolean().optional(),
@@ -110,6 +120,7 @@ export const TelegramAccountSchemaBase = z
     heartbeat: ChannelHeartbeatVisibilitySchema,
     linkPreview: z.boolean().optional(),
     responsePrefix: z.string().optional(),
+    ackReaction: z.string().optional(),
 })
     .strict();
 export const TelegramAccountSchema = TelegramAccountSchemaBase.superRefine((value, ctx) => {
@@ -169,21 +180,12 @@ export const TelegramConfigSchema = TelegramAccountSchemaBase.extend({
 export const DiscordDmSchema = z
     .object({
     enabled: z.boolean().optional(),
-    policy: DmPolicySchema.optional().default("pairing"),
-    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    policy: DmPolicySchema.optional(),
+    allowFrom: DiscordIdListSchema.optional(),
     groupEnabled: z.boolean().optional(),
-    groupChannels: z.array(z.union([z.string(), z.number()])).optional(),
+    groupChannels: DiscordIdListSchema.optional(),
 })
-    .strict()
-    .superRefine((value, ctx) => {
-    requireOpenAllowFrom({
-        policy: value.policy,
-        allowFrom: value.allowFrom,
-        ctx,
-        path: ["allowFrom"],
-        message: 'channels.discord.dm.policy="open" requires channels.discord.dm.allowFrom to include "*"',
-    });
-});
+    .strict();
 export const DiscordGuildChannelSchema = z
     .object({
     allow: z.boolean().optional(),
@@ -192,7 +194,8 @@ export const DiscordGuildChannelSchema = z
     toolsBySender: ToolPolicyBySenderSchema,
     skills: z.array(z.string()).optional(),
     enabled: z.boolean().optional(),
-    users: z.array(z.union([z.string(), z.number()])).optional(),
+    users: DiscordIdListSchema.optional(),
+    roles: DiscordIdListSchema.optional(),
     systemPrompt: z.string().optional(),
     includeThreadStarter: z.boolean().optional(),
     autoThread: z.boolean().optional(),
@@ -205,10 +208,22 @@ export const DiscordGuildSchema = z
     tools: ToolPolicySchema,
     toolsBySender: ToolPolicyBySenderSchema,
     reactionNotifications: z.enum(["off", "own", "all", "allowlist"]).optional(),
-    users: z.array(z.union([z.string(), z.number()])).optional(),
+    users: DiscordIdListSchema.optional(),
+    roles: DiscordIdListSchema.optional(),
     channels: z.record(z.string(), DiscordGuildChannelSchema.optional()).optional(),
 })
     .strict();
+const DiscordUiSchema = z
+    .object({
+    components: z
+        .object({
+        accentColor: HexColorSchema.optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict()
+    .optional();
 export const DiscordAccountSchema = z
     .object({
     name: z.string().optional(),
@@ -217,7 +232,8 @@ export const DiscordAccountSchema = z
     enabled: z.boolean().optional(),
     commands: ProviderCommandsSchema,
     configWrites: z.boolean().optional(),
-    token: z.string().optional(),
+    token: z.string().optional().register(sensitive),
+    proxy: z.string().optional(),
     allowBots: z.boolean().optional(),
     groupPolicy: GroupPolicySchema.optional().default("allowlist"),
     historyLimit: z.number().int().min(0).optional(),
@@ -255,19 +271,25 @@ export const DiscordAccountSchema = z
         .strict()
         .optional(),
     replyToMode: ReplyToModeSchema.optional(),
+    // Aliases for channels.discord.dm.policy / channels.discord.dm.allowFrom. Prefer these for
+    // inheritance in multi-account setups (shallow merge works; nested dm object doesn't).
+    dmPolicy: DmPolicySchema.optional(),
+    allowFrom: DiscordIdListSchema.optional(),
     dm: DiscordDmSchema.optional(),
     guilds: z.record(z.string(), DiscordGuildSchema.optional()).optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
     execApprovals: z
         .object({
         enabled: z.boolean().optional(),
-        approvers: z.array(z.union([z.string(), z.number()])).optional(),
+        approvers: DiscordIdListSchema.optional(),
         agentFilter: z.array(z.string()).optional(),
         sessionFilter: z.array(z.string()).optional(),
         cleanupAfterResolve: z.boolean().optional(),
+        target: z.enum(["dm", "channel", "both"]).optional(),
     })
         .strict()
         .optional(),
+    ui: DiscordUiSchema,
     intents: z
         .object({
         presence: z.boolean().optional(),
@@ -278,13 +300,58 @@ export const DiscordAccountSchema = z
     pluralkit: z
         .object({
         enabled: z.boolean().optional(),
-        token: z.string().optional(),
+        token: z.string().optional().register(sensitive),
     })
         .strict()
         .optional(),
     responsePrefix: z.string().optional(),
+    ackReaction: z.string().optional(),
+    activity: z.string().optional(),
+    status: z.enum(["online", "dnd", "idle", "invisible"]).optional(),
+    activityType: z
+        .union([z.literal(0), z.literal(1), z.literal(2), z.literal(3), z.literal(4), z.literal(5)])
+        .optional(),
+    activityUrl: z.string().url().optional(),
 })
-    .strict();
+    .strict()
+    .superRefine((value, ctx) => {
+    const activityText = typeof value.activity === "string" ? value.activity.trim() : "";
+    const hasActivity = Boolean(activityText);
+    const hasActivityType = value.activityType !== undefined;
+    const activityUrl = typeof value.activityUrl === "string" ? value.activityUrl.trim() : "";
+    const hasActivityUrl = Boolean(activityUrl);
+    if ((hasActivityType || hasActivityUrl) && !hasActivity) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "channels.discord.activity is required when activityType or activityUrl is set",
+            path: ["activity"],
+        });
+    }
+    if (value.activityType === 1 && !hasActivityUrl) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "channels.discord.activityUrl is required when activityType is 1 (Streaming)",
+            path: ["activityUrl"],
+        });
+    }
+    if (hasActivityUrl && value.activityType !== 1) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "channels.discord.activityType must be 1 (Streaming) when activityUrl is set",
+            path: ["activityType"],
+        });
+    }
+    const dmPolicy = value.dmPolicy ?? value.dm?.policy ?? "pairing";
+    const allowFrom = value.allowFrom ?? value.dm?.allowFrom;
+    const allowFromPath = value.allowFrom !== undefined ? ["allowFrom"] : ["dm", "allowFrom"];
+    requireOpenAllowFrom({
+        policy: dmPolicy,
+        allowFrom,
+        ctx,
+        path: [...allowFromPath],
+        message: 'channels.discord.dmPolicy="open" requires channels.discord.allowFrom (or channels.discord.dm.allowFrom) to include "*"',
+    });
+});
 export const DiscordConfigSchema = DiscordAccountSchema.extend({
     accounts: z.record(z.string(), DiscordAccountSchema.optional()).optional(),
 });
@@ -338,6 +405,7 @@ export const GoogleChatAccountSchema = z
     chunkMode: z.enum(["length", "newline"]).optional(),
     blockStreaming: z.boolean().optional(),
     blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
+    streamMode: z.enum(["replace", "status_final", "append"]).optional().default("replace"),
     mediaMaxMb: z.number().positive().optional(),
     replyToMode: ReplyToModeSchema.optional(),
     actions: z
@@ -358,22 +426,13 @@ export const GoogleChatConfigSchema = GoogleChatAccountSchema.extend({
 export const SlackDmSchema = z
     .object({
     enabled: z.boolean().optional(),
-    policy: DmPolicySchema.optional().default("pairing"),
+    policy: DmPolicySchema.optional(),
     allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
     groupEnabled: z.boolean().optional(),
     groupChannels: z.array(z.union([z.string(), z.number()])).optional(),
     replyToMode: ReplyToModeSchema.optional(),
 })
-    .strict()
-    .superRefine((value, ctx) => {
-    requireOpenAllowFrom({
-        policy: value.policy,
-        allowFrom: value.allowFrom,
-        ctx,
-        path: ["allowFrom"],
-        message: 'channels.slack.dm.policy="open" requires channels.slack.dm.allowFrom to include "*"',
-    });
-});
+    .strict();
 export const SlackChannelSchema = z
     .object({
     enabled: z.boolean().optional(),
@@ -391,6 +450,7 @@ export const SlackThreadSchema = z
     .object({
     historyScope: z.enum(["thread", "channel"]).optional(),
     inheritParent: z.boolean().optional(),
+    initialHistoryLimit: z.number().int().min(0).optional(),
 })
     .strict();
 const SlackReplyToModeByChatTypeSchema = z
@@ -404,16 +464,16 @@ export const SlackAccountSchema = z
     .object({
     name: z.string().optional(),
     mode: z.enum(["socket", "http"]).optional(),
-    signingSecret: z.string().optional(),
+    signingSecret: z.string().optional().register(sensitive),
     webhookPath: z.string().optional(),
     capabilities: z.array(z.string()).optional(),
     markdown: MarkdownConfigSchema,
     enabled: z.boolean().optional(),
     commands: ProviderCommandsSchema,
     configWrites: z.boolean().optional(),
-    botToken: z.string().optional(),
-    appToken: z.string().optional(),
-    userToken: z.string().optional(),
+    botToken: z.string().optional().register(sensitive),
+    appToken: z.string().optional().register(sensitive),
+    userToken: z.string().optional().register(sensitive),
     userTokenReadOnly: z.boolean().optional().default(true),
     allowBots: z.boolean().optional(),
     requireMention: z.boolean().optional(),
@@ -425,6 +485,7 @@ export const SlackAccountSchema = z
     chunkMode: z.enum(["length", "newline"]).optional(),
     blockStreaming: z.boolean().optional(),
     blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
+    streaming: z.boolean().optional(),
     mediaMaxMb: z.number().positive().optional(),
     reactionNotifications: z.enum(["off", "own", "all", "allowlist"]).optional(),
     reactionAllowlist: z.array(z.union([z.string(), z.number()])).optional(),
@@ -453,15 +514,32 @@ export const SlackAccountSchema = z
     })
         .strict()
         .optional(),
+    // Aliases for channels.slack.dm.policy / channels.slack.dm.allowFrom. Prefer these for
+    // inheritance in multi-account setups (shallow merge works; nested dm object doesn't).
+    dmPolicy: DmPolicySchema.optional(),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
     dm: SlackDmSchema.optional(),
     channels: z.record(z.string(), SlackChannelSchema.optional()).optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
     responsePrefix: z.string().optional(),
+    ackReaction: z.string().optional(),
 })
-    .strict();
-export const SlackConfigSchema = SlackAccountSchema.extend({
+    .strict()
+    .superRefine((value, ctx) => {
+    const dmPolicy = value.dmPolicy ?? value.dm?.policy ?? "pairing";
+    const allowFrom = value.allowFrom ?? value.dm?.allowFrom;
+    const allowFromPath = value.allowFrom !== undefined ? ["allowFrom"] : ["dm", "allowFrom"];
+    requireOpenAllowFrom({
+        policy: dmPolicy,
+        allowFrom,
+        ctx,
+        path: [...allowFromPath],
+        message: 'channels.slack.dmPolicy="open" requires channels.slack.allowFrom (or channels.slack.dm.allowFrom) to include "*"',
+    });
+});
+export const SlackConfigSchema = SlackAccountSchema.safeExtend({
     mode: z.enum(["socket", "http"]).optional().default("socket"),
-    signingSecret: z.string().optional(),
+    signingSecret: z.string().optional().register(sensitive),
     webhookPath: z.string().optional().default("/slack/events"),
     accounts: z.record(z.string(), SlackAccountSchema.optional()).optional(),
 }).superRefine((value, ctx) => {
@@ -473,16 +551,20 @@ export const SlackConfigSchema = SlackAccountSchema.extend({
             path: ["signingSecret"],
         });
     }
-    if (!value.accounts)
+    if (!value.accounts) {
         return;
+    }
     for (const [accountId, account] of Object.entries(value.accounts)) {
-        if (!account)
+        if (!account) {
             continue;
-        if (account.enabled === false)
+        }
+        if (account.enabled === false) {
             continue;
+        }
         const accountMode = account.mode ?? baseMode;
-        if (accountMode !== "http")
+        if (accountMode !== "http") {
             continue;
+        }
         const accountSecret = account.signingSecret ?? value.signingSecret;
         if (!accountSecret) {
             ctx.addIssue({
@@ -571,7 +653,7 @@ export const IrcNickServSchema = z
     .object({
     enabled: z.boolean().optional(),
     service: z.string().optional(),
-    password: z.string().optional(),
+    password: z.string().optional().register(sensitive),
     passwordFile: z.string().optional(),
     register: z.boolean().optional(),
     registerEmail: z.string().optional(),
@@ -590,7 +672,7 @@ export const IrcAccountSchemaBase = z
     nick: z.string().optional(),
     username: z.string().optional(),
     realname: z.string().optional(),
-    password: z.string().optional(),
+    password: z.string().optional().register(sensitive),
     passwordFile: z.string().optional(),
     nickserv: IrcNickServSchema.optional(),
     channels: z.array(z.string()).optional(),
@@ -612,7 +694,7 @@ export const IrcAccountSchemaBase = z
     responsePrefix: z.string().optional(),
 })
     .strict();
-export const IrcAccountSchema = IrcAccountSchemaBase.superRefine((value, ctx) => {
+function refineIrcAllowFromAndNickserv(value, ctx) {
     requireOpenAllowFrom({
         policy: value.dmPolicy,
         allowFrom: value.allowFrom,
@@ -627,24 +709,14 @@ export const IrcAccountSchema = IrcAccountSchemaBase.superRefine((value, ctx) =>
             message: "channels.irc.nickserv.register=true requires channels.irc.nickserv.registerEmail",
         });
     }
+}
+export const IrcAccountSchema = IrcAccountSchemaBase.superRefine((value, ctx) => {
+    refineIrcAllowFromAndNickserv(value, ctx);
 });
 export const IrcConfigSchema = IrcAccountSchemaBase.extend({
     accounts: z.record(z.string(), IrcAccountSchema.optional()).optional(),
 }).superRefine((value, ctx) => {
-    requireOpenAllowFrom({
-        policy: value.dmPolicy,
-        allowFrom: value.allowFrom,
-        ctx,
-        path: ["allowFrom"],
-        message: 'channels.irc.dmPolicy="open" requires channels.irc.allowFrom to include "*"',
-    });
-    if (value.nickserv?.register && !value.nickserv.registerEmail?.trim()) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["nickserv", "registerEmail"],
-            message: "channels.irc.nickserv.register=true requires channels.irc.nickserv.registerEmail",
-        });
-    }
+    refineIrcAllowFromAndNickserv(value, ctx);
 });
 export const IMessageAccountSchemaBase = z
     .object({
@@ -737,7 +809,7 @@ export const BlueBubblesAccountSchemaBase = z
     configWrites: z.boolean().optional(),
     enabled: z.boolean().optional(),
     serverUrl: z.string().optional(),
-    password: z.string().optional(),
+    password: z.string().optional().register(sensitive),
     webhookPath: z.string().optional(),
     dmPolicy: DmPolicySchema.optional().default("pairing"),
     allowFrom: z.array(BlueBubblesAllowFromEntry).optional(),
@@ -749,6 +821,7 @@ export const BlueBubblesAccountSchemaBase = z
     textChunkLimit: z.number().int().positive().optional(),
     chunkMode: z.enum(["length", "newline"]).optional(),
     mediaMaxMb: z.number().int().positive().optional(),
+    mediaLocalRoots: z.array(z.string()).optional(),
     sendReadReceipts: z.boolean().optional(),
     blockStreaming: z.boolean().optional(),
     blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
@@ -802,7 +875,7 @@ export const MSTeamsConfigSchema = z
     markdown: MarkdownConfigSchema,
     configWrites: z.boolean().optional(),
     appId: z.string().optional(),
-    appPassword: z.string().optional(),
+    appPassword: z.string().optional().register(sensitive),
     tenantId: z.string().optional(),
     webhook: z
         .object({

package/dist/config/zod-schema.session.js

@@ -1,5 +1,8 @@
 import { z } from "zod";
+import { parseByteSize } from "../cli/parse-bytes.js";
+import { parseDurationMs } from "../cli/parse-duration.js";
 import { ElevatedAllowFromSchema } from "./zod-schema.agent-runtime.js";
+import { createAllowDenyChannelRulesSchema } from "./zod-schema.allowdeny.js";
 import { GroupChatSchema, InboundDebounceSchema, NativeCommandsSettingSchema, QueueSchema, TtsConfigSchema, } from "./zod-schema.core.js";
 const SessionResetConfigSchema = z
     .object({
@@ -8,11 +11,17 @@ const SessionResetConfigSchema = z
     idleMinutes: z.number().int().positive().optional(),
 })
     .strict();
+export const SessionSendPolicySchema = createAllowDenyChannelRulesSchema();
 export const SessionSchema = z
     .object({
     scope: z.union([z.literal("per-sender"), z.literal("global")]).optional(),
     dmScope: z
-        .union([z.literal("main"), z.literal("per-peer"), z.literal("per-channel-peer")])
+        .union([
+        z.literal("main"),
+        z.literal("per-peer"),
+        z.literal("per-channel-peer"),
+        z.literal("per-account-channel-peer"),
+    ])
         .optional(),
     identityLinks: z.record(z.string(), z.array(z.string())).optional(),
     resetTriggers: z.array(z.string()).optional(),
@@ -20,6 +29,8 @@ export const SessionSchema = z
     reset: SessionResetConfigSchema.optional(),
     resetByType: z
         .object({
+        direct: SessionResetConfigSchema.optional(),
+        /** @deprecated Use `direct` instead. Kept for backward compatibility. */
         dm: SessionResetConfigSchema.optional(),
         group: SessionResetConfigSchema.optional(),
         thread: SessionResetConfigSchema.optional(),
@@ -38,34 +49,49 @@ export const SessionSchema = z
     ])
         .optional(),
     mainKey: z.string().optional(),
-    sendPolicy: z
+    sendPolicy: SessionSendPolicySchema.optional(),
+    agentToAgent: z
         .object({
-        default: z.union([z.literal("allow"), z.literal("deny")]).optional(),
-        rules: z
-            .array(z
-            .object({
-            action: z.union([z.literal("allow"), z.literal("deny")]),
-            match: z
-                .object({
-                channel: z.string().optional(),
-                chatType: z
-                    .union([z.literal("direct"), z.literal("group"), z.literal("channel")])
-                    .optional(),
-                keyPrefix: z.string().optional(),
-            })
-                .strict()
-                .optional(),
-        })
-            .strict())
-            .optional(),
+        maxPingPongTurns: z.number().int().min(0).max(5).optional(),
     })
         .strict()
         .optional(),
-    agentToAgent: z
+    maintenance: z
         .object({
-        maxPingPongTurns: z.number().int().min(0).max(5).optional(),
+        mode: z.enum(["enforce", "warn"]).optional(),
+        pruneAfter: z.union([z.string(), z.number()]).optional(),
+        /** @deprecated Use pruneAfter instead. */
+        pruneDays: z.number().int().positive().optional(),
+        maxEntries: z.number().int().positive().optional(),
+        rotateBytes: z.union([z.string(), z.number()]).optional(),
     })
         .strict()
+        .superRefine((val, ctx) => {
+        if (val.pruneAfter !== undefined) {
+            try {
+                parseDurationMs(String(val.pruneAfter).trim(), { defaultUnit: "d" });
+            }
+            catch {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ["pruneAfter"],
+                    message: "invalid duration (use ms, s, m, h, d)",
+                });
+            }
+        }
+        if (val.rotateBytes !== undefined) {
+            try {
+                parseByteSize(String(val.rotateBytes).trim(), { defaultUnit: "b" });
+            }
+            catch {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ["rotateBytes"],
+                    message: "invalid size (use b, kb, mb, gb, tb)",
+                });
+            }
+        }
+    })
         .optional(),
 })
     .strict()
@@ -80,6 +106,7 @@ export const MessagesSchema = z
     ackReaction: z.string().optional(),
     ackReactionScope: z.enum(["group-mentions", "group-all", "direct", "all"]).optional(),
     removeAckAfterReply: z.boolean().optional(),
+    suppressToolErrors: z.boolean().optional(),
     tts: TtsConfigSchema,
 })
     .strict()