@elizaos/agent 2.0.0-beta.2 → 2.0.11-beta.6

package/packages/agent/src/config/zod-schema.providers-core.js

@@ -1,969 +0,0 @@
-import { z } from "zod";
-import { normalizeTelegramCommandDescription, normalizeTelegramCommandName, resolveTelegramCustomCommands, } from "./telegram-custom-commands.js";
-import { ToolPolicySchema } from "./zod-schema.agent-runtime.js";
-import { BlockStreamingChunkSchema, BlockStreamingCoalesceSchema, ChannelHeartbeatVisibilitySchema, DmConfigSchema, DmPolicySchema, ExecutableTokenSchema, GroupPolicySchema, MarkdownConfigSchema, MSTeamsReplyStyleSchema, ProviderCommandsSchema, ReplyToModeSchema, RetryConfigSchema, requireOpenAllowFrom, } from "./zod-schema.core.js";
-const ToolPolicyBySenderSchema = z
-    .record(z.string(), ToolPolicySchema)
-    .optional();
-const TelegramInlineButtonsScopeSchema = z.enum([
-    "off",
-    "dm",
-    "group",
-    "all",
-    "allowlist",
-]);
-const TelegramCapabilitiesSchema = z.union([
-    z.array(z.string()),
-    z
-        .object({
-        inlineButtons: TelegramInlineButtonsScopeSchema.optional(),
-    })
-        .strict(),
-]);
-export const TelegramTopicSchema = z
-    .object({
-    requireMention: z.boolean().optional(),
-    skills: z.array(z.string()).optional(),
-    enabled: z.boolean().optional(),
-    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-    systemPrompt: z.string().optional(),
-})
-    .strict();
-export const TelegramGroupSchema = z
-    .object({
-    requireMention: z.boolean().optional(),
-    tools: ToolPolicySchema,
-    toolsBySender: ToolPolicyBySenderSchema,
-    skills: z.array(z.string()).optional(),
-    enabled: z.boolean().optional(),
-    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-    systemPrompt: z.string().optional(),
-    topics: z.record(z.string(), TelegramTopicSchema.optional()).optional(),
-})
-    .strict();
-const TelegramCustomCommandSchema = z
-    .object({
-    command: z.string().transform(normalizeTelegramCommandName),
-    description: z.string().transform(normalizeTelegramCommandDescription),
-})
-    .strict();
-const validateTelegramCustomCommands = (value, ctx) => {
-    if (!value.customCommands || value.customCommands.length === 0) {
-        return;
-    }
-    const { issues } = resolveTelegramCustomCommands({
-        commands: value.customCommands,
-        checkReserved: false,
-        checkDuplicates: false,
-    });
-    for (const issue of issues) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["customCommands", issue.index, issue.field],
-            message: issue.message,
-        });
-    }
-};
-export const TelegramAccountSchemaBase = z
-    .object({
-    name: z.string().optional(),
-    capabilities: TelegramCapabilitiesSchema.optional(),
-    markdown: MarkdownConfigSchema,
-    enabled: z.boolean().optional(),
-    commands: ProviderCommandsSchema,
-    customCommands: z.array(TelegramCustomCommandSchema).optional(),
-    configWrites: z.boolean().optional(),
-    dmPolicy: DmPolicySchema.optional().default("pairing"),
-    botToken: z.string().optional(),
-    tokenFile: z.string().optional(),
-    replyToMode: ReplyToModeSchema.optional(),
-    groups: z.record(z.string(), TelegramGroupSchema.optional()).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"),
-    historyLimit: z.number().int().min(0).optional(),
-    dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(["length", "newline"]).optional(),
-    blockStreaming: z.boolean().optional(),
-    draftChunk: BlockStreamingChunkSchema.optional(),
-    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
-    streamMode: z
-        .enum(["off", "partial", "block"])
-        .optional()
-        .default("partial"),
-    mediaMaxMb: z.number().positive().optional(),
-    timeoutSeconds: z.number().int().positive().optional(),
-    retry: RetryConfigSchema,
-    network: z
-        .object({
-        autoSelectFamily: z.boolean().optional(),
-    })
-        .strict()
-        .optional(),
-    proxy: z.string().optional(),
-    webhookUrl: z.string().optional(),
-    webhookSecret: z.string().optional(),
-    webhookPath: z.string().optional(),
-    actions: z
-        .object({
-        reactions: z.boolean().optional(),
-        sendMessage: z.boolean().optional(),
-        deleteMessage: z.boolean().optional(),
-        sticker: z.boolean().optional(),
-    })
-        .strict()
-        .optional(),
-    reactionNotifications: z.enum(["off", "own", "all"]).optional(),
-    reactionLevel: z.enum(["off", "ack", "minimal", "extensive"]).optional(),
-    heartbeat: ChannelHeartbeatVisibilitySchema,
-    linkPreview: z.boolean().optional(),
-})
-    .strict();
-export const TelegramAccountSchema = TelegramAccountSchemaBase.superRefine((value, ctx) => {
-    requireOpenAllowFrom({
-        policy: value.dmPolicy,
-        allowFrom: value.allowFrom,
-        ctx,
-        path: ["allowFrom"],
-        message: 'channels.telegram.dmPolicy="open" requires channels.telegram.allowFrom to include "*"',
-    });
-    validateTelegramCustomCommands(value, ctx);
-});
-export const TelegramConfigSchema = TelegramAccountSchemaBase.extend({
-    accounts: z.record(z.string(), TelegramAccountSchema.optional()).optional(),
-}).superRefine((value, ctx) => {
-    requireOpenAllowFrom({
-        policy: value.dmPolicy,
-        allowFrom: value.allowFrom,
-        ctx,
-        path: ["allowFrom"],
-        message: 'channels.telegram.dmPolicy="open" requires channels.telegram.allowFrom to include "*"',
-    });
-    validateTelegramCustomCommands(value, ctx);
-    const baseWebhookUrl = typeof value.webhookUrl === "string" ? value.webhookUrl.trim() : "";
-    const baseWebhookSecret = typeof value.webhookSecret === "string" ? value.webhookSecret.trim() : "";
-    if (baseWebhookUrl && !baseWebhookSecret) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "channels.telegram.webhookUrl requires channels.telegram.webhookSecret",
-            path: ["webhookSecret"],
-        });
-    }
-    if (!value.accounts) {
-        return;
-    }
-    for (const [accountId, account] of Object.entries(value.accounts)) {
-        if (!account) {
-            continue;
-        }
-        if (account.enabled === false) {
-            continue;
-        }
-        const accountWebhookUrl = typeof account.webhookUrl === "string" ? account.webhookUrl.trim() : "";
-        if (!accountWebhookUrl) {
-            continue;
-        }
-        const accountSecret = typeof account.webhookSecret === "string"
-            ? account.webhookSecret.trim()
-            : "";
-        if (!accountSecret && !baseWebhookSecret) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: "channels.telegram.accounts.*.webhookUrl requires channels.telegram.webhookSecret or channels.telegram.accounts.*.webhookSecret",
-                path: ["accounts", accountId, "webhookSecret"],
-            });
-        }
-    }
-});
-export const TelegramAccountConnectorSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    phone: z.string().optional(),
-    appId: z.union([z.string(), z.number().int()]).optional(),
-    appHash: z.string().optional(),
-    deviceModel: z.string().optional(),
-    systemVersion: z.string().optional(),
-})
-    .strict();
-export const BlueBubblesConnectorConfigSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    serverUrl: z.string().url().optional(),
-    password: z.string().optional(),
-    webhookPath: z.string().optional(),
-    autoStartCommand: z.string().optional(),
-    autoStartArgs: z.array(z.string()).optional(),
-    autoStartCwd: z.string().optional(),
-    autoStartWaitMs: z.number().int().nonnegative().optional(),
-    dmPolicy: DmPolicySchema.optional(),
-    groupPolicy: GroupPolicySchema.optional(),
-    allowFrom: z.array(z.string()).optional(),
-    groupAllowFrom: z.array(z.string()).optional(),
-    sendReadReceipts: z.boolean().optional(),
-})
-    .strict();
-export const DiscordDmSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    policy: DmPolicySchema.optional().default("pairing"),
-    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-    groupEnabled: z.boolean().optional(),
-    groupChannels: z.array(z.union([z.string(), z.number()])).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 "*"',
-    });
-});
-export const DiscordGuildChannelSchema = z
-    .object({
-    allow: z.boolean().optional(),
-    requireMention: z.boolean().optional(),
-    tools: ToolPolicySchema,
-    toolsBySender: ToolPolicyBySenderSchema,
-    skills: z.array(z.string()).optional(),
-    enabled: z.boolean().optional(),
-    users: z.array(z.union([z.string(), z.number()])).optional(),
-    systemPrompt: z.string().optional(),
-    autoThread: z.boolean().optional(),
-})
-    .strict();
-export const DiscordGuildSchema = z
-    .object({
-    slug: z.string().optional(),
-    requireMention: z.boolean().optional(),
-    tools: ToolPolicySchema,
-    toolsBySender: ToolPolicyBySenderSchema,
-    reactionNotifications: z
-        .enum(["off", "own", "all", "allowlist"])
-        .optional(),
-    users: z.array(z.union([z.string(), z.number()])).optional(),
-    channels: z
-        .record(z.string(), DiscordGuildChannelSchema.optional())
-        .optional(),
-})
-    .strict();
-export const DiscordAccountSchema = z
-    .object({
-    name: z.string().optional(),
-    capabilities: z.array(z.string()).optional(),
-    markdown: MarkdownConfigSchema,
-    enabled: z.boolean().optional(),
-    commands: ProviderCommandsSchema,
-    configWrites: z.boolean().optional(),
-    token: z.string().optional(),
-    syncProfile: z.boolean().optional(),
-    profileName: z.string().optional(),
-    profileAvatar: z.string().optional(),
-    allowBots: z.boolean().optional(),
-    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
-    historyLimit: z.number().int().min(0).optional(),
-    dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(["length", "newline"]).optional(),
-    blockStreaming: z.boolean().optional(),
-    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
-    maxLinesPerMessage: z.number().int().positive().optional(),
-    mediaMaxMb: z.number().positive().optional(),
-    retry: RetryConfigSchema,
-    actions: z
-        .object({
-        reactions: z.boolean().optional(),
-        stickers: z.boolean().optional(),
-        emojiUploads: z.boolean().optional(),
-        stickerUploads: z.boolean().optional(),
-        polls: z.boolean().optional(),
-        permissions: z.boolean().optional(),
-        messages: z.boolean().optional(),
-        threads: z.boolean().optional(),
-        pins: z.boolean().optional(),
-        search: z.boolean().optional(),
-        memberInfo: z.boolean().optional(),
-        roleInfo: z.boolean().optional(),
-        roles: z.boolean().optional(),
-        channelInfo: z.boolean().optional(),
-        voiceStatus: z.boolean().optional(),
-        events: z.boolean().optional(),
-        moderation: z.boolean().optional(),
-        channels: z.boolean().optional(),
-        presence: z.boolean().optional(),
-    })
-        .strict()
-        .optional(),
-    replyToMode: ReplyToModeSchema.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(),
-        agentFilter: z.array(z.string()).optional(),
-        sessionFilter: z.array(z.string()).optional(),
-    })
-        .strict()
-        .optional(),
-    intents: z
-        .object({
-        presence: z.boolean().optional(),
-        guildMembers: z.boolean().optional(),
-    })
-        .strict()
-        .optional(),
-    pluralkit: z
-        .object({
-        enabled: z.boolean().optional(),
-        token: z.string().optional(),
-    })
-        .strict()
-        .optional(),
-})
-    .strict();
-export const DiscordConfigSchema = DiscordAccountSchema.extend({
-    accounts: z.record(z.string(), DiscordAccountSchema.optional()).optional(),
-});
-export const DiscordLocalConfigSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    clientId: z.string().optional(),
-    clientSecret: z.string().optional(),
-    scopes: z.array(z.string()).optional(),
-    messageChannelIds: z.array(z.string()).optional(),
-    sendDelayMs: z.number().int().min(100).optional(),
-})
-    .strict();
-export const GoogleChatDmSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    policy: DmPolicySchema.optional().default("pairing"),
-    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-})
-    .strict()
-    .superRefine((value, ctx) => {
-    requireOpenAllowFrom({
-        policy: value.policy,
-        allowFrom: value.allowFrom,
-        ctx,
-        path: ["allowFrom"],
-        message: 'channels.googlechat.dm.policy="open" requires channels.googlechat.dm.allowFrom to include "*"',
-    });
-});
-export const GoogleChatGroupSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    allow: z.boolean().optional(),
-    requireMention: z.boolean().optional(),
-    users: z.array(z.union([z.string(), z.number()])).optional(),
-    systemPrompt: z.string().optional(),
-})
-    .strict();
-export const GoogleChatAccountSchema = z
-    .object({
-    name: z.string().optional(),
-    capabilities: z.array(z.string()).optional(),
-    enabled: z.boolean().optional(),
-    configWrites: z.boolean().optional(),
-    allowBots: z.boolean().optional(),
-    requireMention: z.boolean().optional(),
-    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
-    groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-    groups: z.record(z.string(), GoogleChatGroupSchema.optional()).optional(),
-    serviceAccount: z
-        .union([z.string(), z.record(z.string(), z.unknown())])
-        .optional(),
-    serviceAccountFile: z.string().optional(),
-    audienceType: z.enum(["app-url", "project-number"]).optional(),
-    audience: z.string().optional(),
-    webhookPath: z.string().optional(),
-    webhookUrl: z.string().optional(),
-    botUser: z.string().optional(),
-    historyLimit: z.number().int().min(0).optional(),
-    dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(["length", "newline"]).optional(),
-    blockStreaming: z.boolean().optional(),
-    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
-    mediaMaxMb: z.number().positive().optional(),
-    replyToMode: ReplyToModeSchema.optional(),
-    actions: z
-        .object({
-        reactions: z.boolean().optional(),
-    })
-        .strict()
-        .optional(),
-    dm: GoogleChatDmSchema.optional(),
-    typingIndicator: z.enum(["none", "message", "reaction"]).optional(),
-})
-    .strict();
-export const GoogleChatConfigSchema = GoogleChatAccountSchema.extend({
-    accounts: z.record(z.string(), GoogleChatAccountSchema.optional()).optional(),
-    defaultAccount: z.string().optional(),
-});
-export const SlackDmSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    policy: DmPolicySchema.optional().default("pairing"),
-    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 "*"',
-    });
-});
-export const SlackChannelSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    allow: z.boolean().optional(),
-    requireMention: z.boolean().optional(),
-    tools: ToolPolicySchema,
-    toolsBySender: ToolPolicyBySenderSchema,
-    allowBots: z.boolean().optional(),
-    users: z.array(z.union([z.string(), z.number()])).optional(),
-    skills: z.array(z.string()).optional(),
-    systemPrompt: z.string().optional(),
-})
-    .strict();
-export const SlackThreadSchema = z
-    .object({
-    historyScope: z.enum(["thread", "channel"]).optional(),
-    inheritParent: z.boolean().optional(),
-})
-    .strict();
-const SlackReplyToModeByChatTypeSchema = z
-    .object({
-    direct: ReplyToModeSchema.optional(),
-    group: ReplyToModeSchema.optional(),
-    channel: ReplyToModeSchema.optional(),
-})
-    .strict();
-export const SlackAccountSchema = z
-    .object({
-    name: z.string().optional(),
-    mode: z.enum(["socket", "http"]).optional(),
-    signingSecret: z.string().optional(),
-    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(),
-    userTokenReadOnly: z.boolean().optional().default(true),
-    allowBots: z.boolean().optional(),
-    requireMention: z.boolean().optional(),
-    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
-    historyLimit: z.number().int().min(0).optional(),
-    dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(["length", "newline"]).optional(),
-    blockStreaming: z.boolean().optional(),
-    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
-    mediaMaxMb: z.number().positive().optional(),
-    reactionNotifications: z
-        .enum(["off", "own", "all", "allowlist"])
-        .optional(),
-    reactionAllowlist: z.array(z.union([z.string(), z.number()])).optional(),
-    replyToMode: ReplyToModeSchema.optional(),
-    replyToModeByChatType: SlackReplyToModeByChatTypeSchema.optional(),
-    thread: SlackThreadSchema.optional(),
-    actions: z
-        .object({
-        reactions: z.boolean().optional(),
-        messages: z.boolean().optional(),
-        pins: z.boolean().optional(),
-        search: z.boolean().optional(),
-        permissions: z.boolean().optional(),
-        memberInfo: z.boolean().optional(),
-        channelInfo: z.boolean().optional(),
-        emojiList: z.boolean().optional(),
-    })
-        .strict()
-        .optional(),
-    slashCommand: z
-        .object({
-        enabled: z.boolean().optional(),
-        name: z.string().optional(),
-        sessionPrefix: z.string().optional(),
-        ephemeral: z.boolean().optional(),
-    })
-        .strict()
-        .optional(),
-    dm: SlackDmSchema.optional(),
-    channels: z.record(z.string(), SlackChannelSchema.optional()).optional(),
-    heartbeat: ChannelHeartbeatVisibilitySchema,
-})
-    .strict();
-export const SlackConfigSchema = SlackAccountSchema.extend({
-    mode: z.enum(["socket", "http"]).optional().default("socket"),
-    signingSecret: z.string().optional(),
-    webhookPath: z.string().optional().default("/slack/events"),
-    accounts: z.record(z.string(), SlackAccountSchema.optional()).optional(),
-}).superRefine((value, ctx) => {
-    const baseMode = value.mode ?? "socket";
-    if (baseMode === "http" && !value.signingSecret) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'channels.slack.mode="http" requires channels.slack.signingSecret',
-            path: ["signingSecret"],
-        });
-    }
-    if (!value.accounts) {
-        return;
-    }
-    for (const [accountId, account] of Object.entries(value.accounts)) {
-        if (!account) {
-            continue;
-        }
-        if (account.enabled === false) {
-            continue;
-        }
-        const accountMode = account.mode ?? baseMode;
-        if (accountMode !== "http") {
-            continue;
-        }
-        const accountSecret = account.signingSecret ?? value.signingSecret;
-        if (!accountSecret) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'channels.slack.accounts.*.mode="http" requires channels.slack.signingSecret or channels.slack.accounts.*.signingSecret',
-                path: ["accounts", accountId, "signingSecret"],
-            });
-        }
-    }
-});
-export const SignalAccountSchemaBase = z
-    .object({
-    name: z.string().optional(),
-    capabilities: z.array(z.string()).optional(),
-    markdown: MarkdownConfigSchema,
-    enabled: z.boolean().optional(),
-    configWrites: z.boolean().optional(),
-    account: z.string().optional(),
-    httpUrl: z.string().optional(),
-    httpHost: z.string().optional(),
-    httpPort: z.number().int().positive().optional(),
-    cliPath: ExecutableTokenSchema.optional(),
-    autoStart: z.boolean().optional(),
-    startupTimeoutMs: z.number().int().min(1000).max(120000).optional(),
-    receiveMode: z
-        .union([z.literal("on-start"), z.literal("manual")])
-        .optional(),
-    ignoreAttachments: z.boolean().optional(),
-    ignoreStories: z.boolean().optional(),
-    sendReadReceipts: z.boolean().optional(),
-    dmPolicy: DmPolicySchema.optional().default("pairing"),
-    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"),
-    historyLimit: z.number().int().min(0).optional(),
-    dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(["length", "newline"]).optional(),
-    blockStreaming: z.boolean().optional(),
-    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
-    mediaMaxMb: z.number().int().positive().optional(),
-    reactionNotifications: z
-        .enum(["off", "own", "all", "allowlist"])
-        .optional(),
-    reactionAllowlist: z.array(z.union([z.string(), z.number()])).optional(),
-    actions: z
-        .object({
-        reactions: z.boolean().optional(),
-    })
-        .strict()
-        .optional(),
-    reactionLevel: z.enum(["off", "ack", "minimal", "extensive"]).optional(),
-    heartbeat: ChannelHeartbeatVisibilitySchema,
-})
-    .strict();
-export const SignalAccountSchema = SignalAccountSchemaBase.superRefine((value, ctx) => {
-    requireOpenAllowFrom({
-        policy: value.dmPolicy,
-        allowFrom: value.allowFrom,
-        ctx,
-        path: ["allowFrom"],
-        message: 'channels.signal.dmPolicy="open" requires channels.signal.allowFrom to include "*"',
-    });
-});
-export const SignalConfigSchema = SignalAccountSchemaBase.extend({
-    accounts: z.record(z.string(), SignalAccountSchema.optional()).optional(),
-}).superRefine((value, ctx) => {
-    requireOpenAllowFrom({
-        policy: value.dmPolicy,
-        allowFrom: value.allowFrom,
-        ctx,
-        path: ["allowFrom"],
-        message: 'channels.signal.dmPolicy="open" requires channels.signal.allowFrom to include "*"',
-    });
-});
-export const IMessageAccountSchemaBase = z
-    .object({
-    name: z.string().optional(),
-    capabilities: z.array(z.string()).optional(),
-    markdown: MarkdownConfigSchema,
-    enabled: z.boolean().optional(),
-    configWrites: z.boolean().optional(),
-    cliPath: ExecutableTokenSchema.optional(),
-    dbPath: z.string().optional(),
-    remoteHost: z.string().optional(),
-    service: z
-        .union([z.literal("imessage"), z.literal("sms"), z.literal("auto")])
-        .optional(),
-    region: z.string().optional(),
-    dmPolicy: DmPolicySchema.optional().default("pairing"),
-    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"),
-    historyLimit: z.number().int().min(0).optional(),
-    dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
-    includeAttachments: z.boolean().optional(),
-    mediaMaxMb: z.number().int().positive().optional(),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(["length", "newline"]).optional(),
-    blockStreaming: z.boolean().optional(),
-    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
-    groups: z
-        .record(z.string(), z
-        .object({
-        requireMention: z.boolean().optional(),
-        tools: ToolPolicySchema,
-        toolsBySender: ToolPolicyBySenderSchema,
-    })
-        .strict()
-        .optional())
-        .optional(),
-    heartbeat: ChannelHeartbeatVisibilitySchema,
-})
-    .strict();
-export const IMessageAccountSchema = IMessageAccountSchemaBase.superRefine((value, ctx) => {
-    requireOpenAllowFrom({
-        policy: value.dmPolicy,
-        allowFrom: value.allowFrom,
-        ctx,
-        path: ["allowFrom"],
-        message: 'channels.imessage.dmPolicy="open" requires channels.imessage.allowFrom to include "*"',
-    });
-});
-export const IMessageConfigSchema = IMessageAccountSchemaBase.extend({
-    accounts: z.record(z.string(), IMessageAccountSchema.optional()).optional(),
-}).superRefine((value, ctx) => {
-    requireOpenAllowFrom({
-        policy: value.dmPolicy,
-        allowFrom: value.allowFrom,
-        ctx,
-        path: ["allowFrom"],
-        message: 'channels.imessage.dmPolicy="open" requires channels.imessage.allowFrom to include "*"',
-    });
-});
-// ── Twitch chat connector schema ──────────────────────────────────────────
-export const TwitchConnectorConfigSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    username: z.string().optional(),
-    clientId: z.string().optional(),
-    accessToken: z.string().optional(),
-    clientSecret: z.string().optional(),
-    refreshToken: z.string().optional(),
-    channel: z.string().optional(),
-    channels: z.string().optional(),
-    requireMention: z.boolean().optional(),
-    allowedRoles: z.string().optional(),
-})
-    .strict();
-// ── Streaming destination schemas ──────────────────────────────────────────
-export const TwitchStreamConfigSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    streamKey: z.string().optional(),
-})
-    .strict();
-export const YoutubeStreamConfigSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    streamKey: z.string().optional(),
-    rtmpUrl: z.string().url().optional(),
-})
-    .strict();
-export const CustomRtmpConfigSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    rtmpUrl: z.string().optional(),
-    rtmpKey: z.string().optional(),
-})
-    .strict();
-export const PumpfunStreamConfigSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    streamKey: z.string().optional(),
-    rtmpUrl: z.string().optional(),
-})
-    .strict();
-export const XStreamConfigSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    streamKey: z.string().optional(),
-    rtmpUrl: z.string().optional(),
-})
-    .strict();
-export const NamedRtmpSourceSchema = z
-    .object({
-    id: z.string().min(1),
-    name: z.string().optional(),
-    rtmpUrl: z.string().min(1),
-    rtmpKey: z.string().min(1),
-})
-    .strict();
-export const MSTeamsChannelSchema = z
-    .object({
-    requireMention: z.boolean().optional(),
-    tools: ToolPolicySchema,
-    toolsBySender: ToolPolicyBySenderSchema,
-    replyStyle: MSTeamsReplyStyleSchema.optional(),
-})
-    .strict();
-export const MSTeamsTeamSchema = z
-    .object({
-    requireMention: z.boolean().optional(),
-    tools: ToolPolicySchema,
-    toolsBySender: ToolPolicyBySenderSchema,
-    replyStyle: MSTeamsReplyStyleSchema.optional(),
-    channels: z.record(z.string(), MSTeamsChannelSchema.optional()).optional(),
-})
-    .strict();
-export const MSTeamsConfigSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    capabilities: z.array(z.string()).optional(),
-    markdown: MarkdownConfigSchema,
-    configWrites: z.boolean().optional(),
-    appId: z.string().optional(),
-    appPassword: z.string().optional(),
-    tenantId: z.string().optional(),
-    webhook: z
-        .object({
-        port: z.number().int().positive().optional(),
-        path: z.string().optional(),
-    })
-        .strict()
-        .optional(),
-    dmPolicy: DmPolicySchema.optional().default("pairing"),
-    allowFrom: z.array(z.string()).optional(),
-    groupAllowFrom: z.array(z.string()).optional(),
-    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(["length", "newline"]).optional(),
-    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
-    mediaAllowHosts: z.array(z.string()).optional(),
-    mediaAuthAllowHosts: z.array(z.string()).optional(),
-    requireMention: z.boolean().optional(),
-    historyLimit: z.number().int().min(0).optional(),
-    dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
-    replyStyle: MSTeamsReplyStyleSchema.optional(),
-    teams: z.record(z.string(), MSTeamsTeamSchema.optional()).optional(),
-    /** Max media size in MB (default: 100MB for OneDrive upload support). */
-    mediaMaxMb: z.number().positive().optional(),
-    /** SharePoint site ID for file uploads in group chats/channels (e.g., "contoso.sharepoint.com,guid1,guid2") */
-    sharePointSiteId: z.string().optional(),
-    heartbeat: ChannelHeartbeatVisibilitySchema,
-})
-    .strict()
-    .superRefine((value, ctx) => {
-    requireOpenAllowFrom({
-        policy: value.dmPolicy,
-        allowFrom: value.allowFrom,
-        ctx,
-        path: ["allowFrom"],
-        message: 'channels.msteams.dmPolicy="open" requires channels.msteams.allowFrom to include "*"',
-    });
-});
-export const WhatsAppAccountSchema = z
-    .object({
-    name: z.string().optional(),
-    capabilities: z.array(z.string()).optional(),
-    markdown: MarkdownConfigSchema,
-    configWrites: z.boolean().optional(),
-    enabled: z.boolean().optional(),
-    sendReadReceipts: z.boolean().optional(),
-    messagePrefix: z.string().optional(),
-    /** Override auth directory for this WhatsApp account (Baileys multi-file auth state). */
-    authDir: z.string().optional(),
-    dmPolicy: DmPolicySchema.optional().default("pairing"),
-    selfChatMode: z.boolean().optional(),
-    allowFrom: z.array(z.string()).optional(),
-    groupAllowFrom: z.array(z.string()).optional(),
-    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
-    historyLimit: z.number().int().min(0).optional(),
-    dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(["length", "newline"]).optional(),
-    mediaMaxMb: z.number().int().positive().optional(),
-    blockStreaming: z.boolean().optional(),
-    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
-    groups: z
-        .record(z.string(), z
-        .object({
-        requireMention: z.boolean().optional(),
-        tools: ToolPolicySchema,
-        toolsBySender: ToolPolicyBySenderSchema,
-    })
-        .strict()
-        .optional())
-        .optional(),
-    ackReaction: z
-        .object({
-        emoji: z.string().optional(),
-        direct: z.boolean().optional().default(true),
-        group: z
-            .enum(["always", "mentions", "never"])
-            .optional()
-            .default("mentions"),
-    })
-        .strict()
-        .optional(),
-    debounceMs: z.number().int().nonnegative().optional().default(0),
-    heartbeat: ChannelHeartbeatVisibilitySchema,
-})
-    .strict()
-    .superRefine((value, ctx) => {
-    if (value.dmPolicy !== "open") {
-        return;
-    }
-    const allow = (value.allowFrom ?? [])
-        .map((v) => String(v).trim())
-        .filter(Boolean);
-    if (allow.includes("*")) {
-        return;
-    }
-    ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["allowFrom"],
-        message: 'channels.whatsapp.accounts.*.dmPolicy="open" requires allowFrom to include "*"',
-    });
-});
-export const WhatsAppConfigSchema = z
-    .object({
-    accounts: z.record(z.string(), WhatsAppAccountSchema.optional()).optional(),
-    capabilities: z.array(z.string()).optional(),
-    markdown: MarkdownConfigSchema,
-    configWrites: z.boolean().optional(),
-    sendReadReceipts: z.boolean().optional(),
-    dmPolicy: DmPolicySchema.optional().default("pairing"),
-    messagePrefix: z.string().optional(),
-    selfChatMode: z.boolean().optional(),
-    allowFrom: z.array(z.string()).optional(),
-    groupAllowFrom: z.array(z.string()).optional(),
-    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
-    historyLimit: z.number().int().min(0).optional(),
-    dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(["length", "newline"]).optional(),
-    mediaMaxMb: z.number().int().positive().optional().default(50),
-    blockStreaming: z.boolean().optional(),
-    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
-    actions: z
-        .object({
-        reactions: z.boolean().optional(),
-        sendMessage: z.boolean().optional(),
-        polls: z.boolean().optional(),
-    })
-        .strict()
-        .optional(),
-    groups: z
-        .record(z.string(), z
-        .object({
-        requireMention: z.boolean().optional(),
-        tools: ToolPolicySchema,
-        toolsBySender: ToolPolicyBySenderSchema,
-    })
-        .strict()
-        .optional())
-        .optional(),
-    ackReaction: z
-        .object({
-        emoji: z.string().optional(),
-        direct: z.boolean().optional().default(true),
-        group: z
-            .enum(["always", "mentions", "never"])
-            .optional()
-            .default("mentions"),
-    })
-        .strict()
-        .optional(),
-    debounceMs: z.number().int().nonnegative().optional().default(0),
-    heartbeat: ChannelHeartbeatVisibilitySchema,
-})
-    .strict()
-    .superRefine((value, ctx) => {
-    if (value.dmPolicy !== "open") {
-        return;
-    }
-    const allow = (value.allowFrom ?? [])
-        .map((v) => String(v).trim())
-        .filter(Boolean);
-    if (allow.includes("*")) {
-        return;
-    }
-    ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["allowFrom"],
-        message: 'channels.whatsapp.dmPolicy="open" requires channels.whatsapp.allowFrom to include "*"',
-    });
-});
-export const TwitterConfigSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    // Authentication
-    apiKey: z.string().optional(),
-    apiSecretKey: z.string().optional(),
-    accessToken: z.string().optional(),
-    accessTokenSecret: z.string().optional(),
-    // Posting configuration
-    postEnable: z.boolean().optional().default(true),
-    postImmediately: z.boolean().optional().default(false),
-    postIntervalMin: z.number().int().positive().optional().default(90),
-    postIntervalMax: z.number().int().positive().optional().default(180),
-    postIntervalVariance: z.number().min(0).max(1).optional().default(0.1),
-    // Interaction settings
-    searchEnable: z.boolean().optional().default(false),
-    autoRespondMentions: z.boolean().optional().default(true),
-    enableActionProcessing: z.boolean().optional().default(true),
-    timelineAlgorithm: z
-        .enum(["weighted", "latest"])
-        .optional()
-        .default("weighted"),
-    // DM settings
-    dmPolicy: DmPolicySchema.optional().default("pairing"),
-    // Safety and testing
-    dryRun: z.boolean().optional().default(false),
-    retryLimit: z.number().int().positive().optional().default(3),
-    pollInterval: z.number().int().positive().optional().default(120),
-    // Advanced
-    maxTweetLength: z.number().int().positive().optional().default(4000),
-    configWrites: z.boolean().optional(),
-})
-    .strict();