@openclaw/discord 2026.8.1 → 2026.8.33

package/dist/.setup/config-schema-B797-Spt.mjs

@@ -0,0 +1,669 @@
+import { normalizeLegacyDmAliases } from "openclaw/plugin-sdk/channel-config-helpers";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { buildSecretInputSchema, registerSensitiveConfigSchema } from "openclaw/plugin-sdk/secret-input";
+import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
+import { ChannelBotLoopProtectionSchema, ChannelDangerouslyAllowNameMatchingSchema, ChannelPreviewStreamingConfigSchema, ChannelStreamingProgressSchema, ProviderCommandsSchema, TtsConfigSchema, buildChannelAccountSchemaParts, buildChannelAllowBotsSchema, buildChannelConfigSchema, buildChannelExecApprovalsSchema, buildChannelReactionShape, buildGroupEntrySchema, requireAllowlistAllowFrom, requireOpenAllowFrom } from "openclaw/plugin-sdk/channel-config-schema";
+import { asObjectRecord } from "openclaw/plugin-sdk/runtime-doctor-migrations";
+import { z } from "zod";
+//#region extensions/discord/src/config-ui-hints.ts
+const discordChannelConfigUiHints = {
+	"": {
+		label: "Discord",
+		help: "Discord channel provider configuration for bot auth, retry policy, streaming, thread bindings, and optional voice capabilities. Keep privileged intents and advanced features disabled unless needed."
+	},
+	...createChannelConfigUiHints({
+		channelLabel: "Discord",
+		dmPolicy: { channelKey: "discord" },
+		configWrites: true,
+		mentionPatterns: {
+			targetDescription: "Discord channel IDs",
+			policyNote: "Native Discord @mentions still trigger even when regex patterns are denied.",
+			denyNote: "Native @mentions still trigger."
+		},
+		nativeCommands: true,
+		streaming: {
+			"": "Discord preview streaming is off by default. Set mode to \"partial\", \"block\", or \"progress\" to opt in. Run openclaw doctor --fix to migrate legacy keys.",
+			mode: "Discord preview mode: \"off\" | \"partial\" | \"block\" | \"progress\". Default: \"off\".",
+			chunkMode: "Chunking mode for outbound Discord text delivery: \"length\" (default) or \"newline\".",
+			"block.enabled": "Enable normal Discord block replies. This takes precedence over editable preview delivery.",
+			"block.coalesce": "Merge streamed Discord block replies before final delivery.",
+			"preview.chunk.minChars": "Minimum chars before emitting a Discord stream preview update when channels.discord.streaming.mode=\"block\" (default: 200).",
+			"preview.chunk.maxChars": "Target max size for a Discord stream preview chunk when channels.discord.streaming.mode=\"block\" (default: 800; clamped to channels.discord.textChunkLimit).",
+			"preview.chunk.breakPreference": "Preferred breakpoints for Discord draft chunks (paragraph | newline | sentence). Default: paragraph.",
+			"preview.toolProgress": "Show tool/progress activity in the live draft preview message (default: true). Set false to hide interim tool updates while the draft preview stays active.",
+			"preview.commandText": "Command/exec detail in preview tool-progress lines: \"status\" is the safe default; \"raw\" opts into command text."
+		},
+		progress: { includeCommentary: true }
+	}),
+	joinIntro: {
+		label: "Discord Guild Join Introduction",
+		help: "Post one brief, room-specific introduction when the bot joins an allowed Discord guild (default: true). Account settings override the channel-wide setting."
+	},
+	proxy: {
+		label: "Discord Proxy URL",
+		help: "Proxy URL for Discord gateway + API requests (app-id lookup and allowlist resolution). Set per account via channels.discord.accounts.<id>.proxy."
+	},
+	maxLinesPerMessage: {
+		label: "Discord Max Lines Per Message",
+		help: "Soft max line count per Discord message (default: 17)."
+	},
+	suppressEmbeds: {
+		label: "Discord Suppress Link Embeds",
+		help: "Suppress Discord-generated link embeds on outbound messages by default. Explicit embeds still send normally. Default: true."
+	},
+	"thread.inheritParent": {
+		label: "Discord Thread Parent Inheritance",
+		help: "If true, Discord thread sessions inherit the parent channel transcript (default: false)."
+	},
+	"threadBindings.enabled": {
+		label: "Discord Thread Binding Enabled",
+		help: "Enable Discord thread-bound session spawning, routing, and delivery. Overrides session.threadBindings.enabled when set."
+	},
+	"threadBindings.idleHours": {
+		label: "Discord Thread Binding Idle Timeout (hours)",
+		help: "Inactivity window in hours for Discord thread-bound sessions. Set 0 to disable idle expiry (default: 24). Overrides session.threadBindings.idleHours when set."
+	},
+	"threadBindings.maxAgeHours": {
+		label: "Discord Thread Binding Max Age (hours)",
+		help: "Optional hard max age in hours for Discord thread-bound sessions. Set 0 to disable hard cap (default: 0). Overrides session.threadBindings.maxAgeHours when set."
+	},
+	"threadBindings.spawnSessions": {
+		label: "Discord Thread-Bound Session Spawn",
+		help: "Allow sessions_spawn(thread=true) and ACP thread spawns to auto-create and bind Discord threads (default: true). Set false to disable for this account/channel."
+	},
+	"threadBindings.defaultSpawnContext": {
+		label: "Discord Thread Spawn Context",
+		help: "Default native subagent context for thread-bound spawns. \"fork\" starts from the requester transcript; \"isolated\" starts clean. Default: \"fork\"."
+	},
+	"agentComponents.ttlMs": {
+		label: "Discord Component TTL (ms)",
+		help: "How long sent Discord component callbacks remain registered. Default is 1800000 (30 minutes); maximum is 86400000 (24 hours)."
+	},
+	"intents.messageContent": {
+		label: "Discord Message Content Intent",
+		help: "Request the privileged Message Content intent (default: true). Set false only for mention-only guild operation when Discord cannot grant the intent; DMs and explicit mentions still include message content."
+	},
+	"intents.presence": {
+		label: "Discord Presence Intent",
+		help: "Enable the Guild Presences privileged intent. Must also be enabled in the Discord Developer Portal. Allows tracking user activities (e.g. Spotify). Default: false."
+	},
+	"intents.guildMembers": {
+		label: "Discord Guild Members Intent",
+		help: "Enable the Guild Members privileged intent. Must also be enabled in the Discord Developer Portal. Default: false."
+	},
+	"intents.voiceStates": {
+		label: "Discord Voice States Intent",
+		help: "Enable the Guild Voice States intent. Defaults to the effective Discord voice setting; set true only for Discord voice channel conversations."
+	},
+	"voice.enabled": {
+		label: "Discord Voice Enabled",
+		help: "Enable Discord voice channel conversations. Text-only Discord configs leave voice off by default; set true to enable /vc commands and the Guild Voice States intent."
+	},
+	"voice.model": {
+		label: "Discord Voice Model",
+		help: "Optional LLM model override for Discord voice channel responses and realtime agent consults (for example openai/gpt-5.6-sol). Leave unset to inherit the routed agent model."
+	},
+	"voice.mode": {
+		label: "Discord Voice Mode",
+		help: "Conversation mode: agent-proxy (default) uses realtime voice as the microphone/speaker for the routed OpenClaw agent, stt-tts uses batch speech-to-text plus TTS, and bidi lets the realtime provider converse directly with the OpenClaw consult tool."
+	},
+	"voice.agentSession": {
+		label: "Discord Voice Agent Session",
+		help: "Controls which OpenClaw conversation receives voice turns. Leave unset for the voice channel session, or set mode=\"target\" with a Discord target such as channel:123 to make voice an extension of an existing text channel session."
+	},
+	"voice.agentSession.target": {
+		label: "Discord Voice Agent Session Target",
+		help: "Discord target used when voice.agentSession.mode=\"target\", for example channel:123."
+	},
+	"voice.followUsersEnabled": {
+		label: "Discord Voice Follow Users Enabled",
+		help: "Toggle Discord voice follow-users behavior without removing the saved voice.followUsers list. Defaults to true when followUsers is configured."
+	},
+	"voice.followUsers": {
+		label: "Discord Voice Follow Users",
+		help: "Discord user IDs to follow into voice channels. The bot joins when a followed user joins or moves, and leaves when that user disconnects."
+	},
+	"voice.realtime.provider": {
+		label: "Discord Realtime Provider",
+		help: "Realtime voice provider for agent-proxy or bidi Discord voice modes, such as openai."
+	},
+	"voice.realtime.model": {
+		label: "Discord Realtime Model",
+		help: "Provider realtime session model, such as gpt-realtime-2.1. This is separate from voice.model, which remains the OpenClaw agent brain model."
+	},
+	"voice.realtime.speakerVoice": {
+		label: "Discord Realtime Speaker Voice",
+		help: "Provider realtime output voice name, such as cedar."
+	},
+	"voice.realtime.speakerVoiceId": {
+		label: "Discord Realtime Speaker Voice ID",
+		help: "Provider realtime output voice id."
+	},
+	"voice.realtime.toolPolicy": {
+		label: "Discord Realtime Tool Policy",
+		help: "Tool policy for the OpenClaw agent consult tool in realtime voice modes: safe-read-only, owner, or none. Default is owner for agent-proxy and safe-read-only for bidi."
+	},
+	"voice.realtime.consultPolicy": {
+		label: "Discord Realtime Consult Policy",
+		help: "Use always to strongly prefer the OpenClaw agent brain for substantive realtime turns. agent-proxy defaults to always."
+	},
+	"voice.realtime.requireWakeName": {
+		label: "Discord Realtime Require Wake Name",
+		help: "Control OpenAI agent-proxy wake-name gating. Unset listens naturally with one human and requires a wake name with two or more; true always requires one and false never does."
+	},
+	"voice.realtime.wakeNames": {
+		label: "Discord Realtime Wake Names",
+		help: "One- or two-word activation names used whenever OpenAI agent-proxy Discord realtime voice has an active wake-name gate."
+	},
+	"voice.realtime.bootstrapContextFiles": {
+		label: "Discord Realtime Bootstrap Context Files",
+		help: "Agent profile bootstrap files included in realtime provider instructions for direct voice identity/persona grounding. Defaults to IDENTITY.md, USER.md, and SOUL.md; set [] to disable."
+	},
+	"voice.realtime.bargeIn": {
+		label: "Discord Realtime Barge-In",
+		help: "Allow Discord speaker-start events to interrupt active realtime playback. Set true to keep manual interruption when provider input-audio interruption is disabled for echo control."
+	},
+	"voice.realtime.minBargeInAudioEndMs": {
+		label: "Discord Realtime Minimum Barge-In Audio (ms)",
+		help: "Minimum assistant playback duration before a Discord barge-in truncates realtime audio. Default: 250; set 0 for immediate interruption in low-echo rooms."
+	},
+	"voice.realtime.providers": {
+		label: "Discord Realtime Provider Settings",
+		help: "Provider-specific realtime voice settings keyed by provider id.",
+		advanced: true
+	},
+	"voice.autoJoin": {
+		label: "Discord Voice Auto-Join",
+		help: "Voice channels to auto-join (list of guildId/channelId entries). Set whenOccupied on an entry to connect only while humans are present."
+	},
+	"voice.autoJoin.*.whenOccupied": {
+		label: "Discord Voice Auto-Join When Occupied",
+		help: "Join and remain in this auto-managed voice channel only while at least one human is present. The OpenClaw bot and other bots do not count. Default: false."
+	},
+	"voice.allowedChannels": {
+		label: "Discord Voice Allowed Channels",
+		help: "Optional voice channel residency allowlist. When set, /vc join, auto-join, and bot voice-state moves are restricted to these guildId/channelId entries. Leave unset to allow any voice channel."
+	},
+	"voice.daveEncryption": {
+		label: "Discord Voice DAVE Encryption",
+		help: "Toggle DAVE end-to-end encryption for Discord voice joins (default: true in @discordjs/voice; Discord may require this)."
+	},
+	"voice.decryptionFailureTolerance": {
+		label: "Discord Voice Decrypt Failure Tolerance",
+		help: "Consecutive decrypt failures before DAVE attempts session recovery (passed to @discordjs/voice; default: 24)."
+	},
+	"voice.connectTimeoutMs": {
+		label: "Discord Voice Connect Timeout (ms)",
+		help: "Initial @discordjs/voice Ready wait before a join is treated as failed. Default: 30000."
+	},
+	"voice.reconnectGraceMs": {
+		label: "Discord Voice Reconnect Grace (ms)",
+		help: "Grace period for a disconnected Discord voice session to enter Signalling or Connecting before OpenClaw destroys it. Default: 15000."
+	},
+	"voice.captureSilenceGraceMs": {
+		label: "Discord Voice Capture Silence Grace (ms)",
+		help: "Silence window after Discord reports a speaker ended before OpenClaw finalizes the audio segment for transcription. Default: 2000."
+	},
+	"voice.tts": {
+		label: "Discord Voice Text-to-Speech",
+		help: "Optional TTS overrides for Discord voice playback (merged with tts)."
+	},
+	"pluralkit.enabled": {
+		label: "Discord PluralKit Enabled",
+		help: "Resolve PluralKit proxied messages and treat system members as distinct senders."
+	},
+	"pluralkit.token": {
+		label: "Discord PluralKit Token",
+		help: "Optional PluralKit token for resolving private systems or members."
+	},
+	activity: {
+		label: "Discord Presence Activity",
+		help: "Discord presence activity text (defaults to custom status)."
+	},
+	status: {
+		label: "Discord Presence Status",
+		help: "Discord presence status (online, dnd, idle, invisible)."
+	},
+	"autoPresence.enabled": {
+		label: "Discord Auto Presence Enabled",
+		help: "Enable automatic Discord bot presence updates based on runtime/model availability signals. When enabled: healthy=>online, degraded/unknown=>idle, exhausted/unavailable=>dnd."
+	},
+	"autoPresence.intervalMs": {
+		label: "Discord Auto Presence Check Interval (ms)",
+		help: "How often to evaluate Discord auto-presence state in milliseconds (default: 30000)."
+	},
+	"autoPresence.minUpdateIntervalMs": {
+		label: "Discord Auto Presence Min Update Interval (ms)",
+		help: "Minimum time between actual Discord presence update calls in milliseconds (default: 15000). Prevents status spam on noisy state changes."
+	},
+	"guilds.*.presenceEvents": {
+		label: "Discord Online Presence Events",
+		help: "Route selected human offline-to-online transitions into the configured guild channel as agent system events. Requires the Guild Presences privileged intent and an enabled agent heartbeat."
+	},
+	"guilds.*.presenceEvents.enabled": {
+		label: "Discord Online Presence Events Enabled",
+		help: "Enable online-presence agent wakes for this guild. Defaults to true when presenceEvents is configured."
+	},
+	"guilds.*.presenceEvents.channelId": {
+		label: "Discord Online Presence Target Channel",
+		help: "Numeric Discord channel ID whose routed agent session receives online-presence events and greeting delivery."
+	},
+	"guilds.*.presenceEvents.users": {
+		label: "Discord Online Presence User IDs",
+		help: "Optional immutable Discord user ID allowlist. Omit to include all human members in the guild."
+	},
+	"guilds.*.presenceEvents.reconnectSuppressSeconds": {
+		label: "Discord Online Presence Reconnect Suppression",
+		help: "Suppress online-presence events for this many seconds after a new Gateway session while guild presence state is rebuilt. Resumed sessions are unaffected. 0 disables. Default: 300."
+	},
+	"guilds.*.presenceEvents.burstLimit": {
+		label: "Discord Online Presence Burst Limit",
+		help: "Maximum successfully queued online-presence events for this guild per burst window; the rest are suppressed and logged once. Default: 8."
+	},
+	"guilds.*.presenceEvents.burstWindowSeconds": {
+		label: "Discord Online Presence Burst Window",
+		help: "Sliding window in seconds used for burst detection. Default: 60."
+	},
+	activityType: {
+		label: "Discord Presence Activity Type",
+		help: "Discord presence activity type (0=Playing,1=Streaming,2=Listening,3=Watching,4=Custom,5=Competing)."
+	},
+	activityUrl: {
+		label: "Discord Presence Activity URL",
+		help: "Discord presence streaming URL (required for activityType=1)."
+	},
+	allowBots: {
+		label: "Discord Allow Bot Messages",
+		help: "Allow bot-authored messages to trigger Discord replies (default: false). Set \"mentions\" to only accept bot messages that mention the bot."
+	},
+	botLoopProtection: {
+		label: "Discord Bot Loop Protection",
+		help: "Sliding-window guard for bot-to-bot Discord loops. Default is enabled whenever allowBots lets bot-authored messages reach dispatch."
+	},
+	"botLoopProtection.enabled": {
+		label: "Discord Bot Loop Protection Enabled",
+		help: "Enable the bot-pair loop guard. Defaults to true when allowBots is true or \"mentions\", and false when bot messages are ignored."
+	},
+	"botLoopProtection.maxEventsPerWindow": {
+		label: "Discord Bot Pair Events Per Window",
+		help: "Maximum messages a single Discord bot pair may exchange in the configured window before suppression starts. Default: 20."
+	},
+	"botLoopProtection.windowSeconds": {
+		label: "Discord Bot Loop Window Seconds",
+		help: "Sliding window length in seconds for Discord bot-pair loop budgets. Default: 60."
+	},
+	"botLoopProtection.cooldownSeconds": {
+		label: "Discord Bot Loop Cooldown Seconds",
+		help: "Seconds to suppress a Discord bot pair after it exceeds the loop budget. Default: 60."
+	},
+	mentionAliases: {
+		label: "Discord Mention Aliases",
+		help: "Map outbound @handle text to stable Discord user IDs before sending. Set per account via channels.discord.accounts.<id>.mentionAliases."
+	},
+	token: {
+		label: "Discord Bot Token",
+		help: "Discord bot token used for gateway and REST API authentication for this provider account. Keep this secret out of committed config and rotate immediately after any leak.",
+		sensitive: true
+	},
+	applicationId: {
+		label: "Discord Application ID",
+		help: "Optional Discord application/client ID. Set this when hosted environments cannot reach Discord's application lookup endpoint during startup."
+	},
+	activities: {
+		label: "Discord Activities",
+		help: "Enable the Discord Activity presenter for the core show_widget tool on this account. Activity routes and the launch handler remain disabled when this block is absent."
+	},
+	"activities.clientSecret": {
+		label: "Discord Activities Client Secret",
+		help: "OAuth2 client secret for the Discord application. DISCORD_CLIENT_SECRET is used when this field is unset.",
+		sensitive: true
+	},
+	"activities.applicationId": {
+		label: "Discord Activities Application ID",
+		help: "Optional Activity application ID. Defaults to the bot application ID learned at gateway startup."
+	}
+};
+//#endregion
+//#region extensions/discord/src/config-schema.ts
+const SecretInputSchema = buildSecretInputSchema();
+const DiscordPreviewStreamingConfigSchema = ChannelPreviewStreamingConfigSchema.extend({ progress: ChannelStreamingProgressSchema.optional() }).strict();
+const DiscordIdSchema = z.union([z.string(), z.number()]).transform((value, ctx) => {
+	if (typeof value === "number") {
+		if (!Number.isSafeInteger(value) || value < 0) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: `Discord ID "${String(value)}" is not a valid non-negative safe integer. Wrap it in quotes in your config file.`
+			});
+			return z.NEVER;
+		}
+		return String(value);
+	}
+	return value;
+}).pipe(z.string());
+const DiscordIdListSchema = z.array(DiscordIdSchema);
+const DiscordSnowflakeStringSchema = z.string().regex(/^\d+$/, "Discord user ID must be numeric");
+const DiscordDmSchema = z.object({
+	enabled: z.boolean().optional(),
+	groupEnabled: z.boolean().optional(),
+	groupChannels: DiscordIdListSchema.optional()
+}).strict();
+const DiscordPresenceEventsSchema = z.object({
+	enabled: z.boolean().optional(),
+	channelId: DiscordSnowflakeStringSchema,
+	users: z.array(DiscordSnowflakeStringSchema).optional(),
+	reconnectSuppressSeconds: z.number().int().min(0).optional(),
+	burstLimit: z.number().int().positive().optional(),
+	burstWindowSeconds: z.number().int().positive().optional()
+}).strict();
+const DiscordThreadSchema = z.object({ inheritParent: z.boolean().optional() }).strict();
+const DiscordGuildChannelSchema = buildGroupEntrySchema({
+	ignoreOtherMentions: z.boolean().optional(),
+	users: DiscordIdListSchema.optional(),
+	roles: DiscordIdListSchema.optional(),
+	includeThreadStarter: z.boolean().optional(),
+	autoThread: z.boolean().optional(),
+	/** Naming strategy for auto-created threads. "message" uses message text; "generated" creates an LLM title after thread creation. */
+	autoThreadName: z.enum(["message", "generated"]).optional(),
+	/** Archive duration for auto-created threads in minutes. Discord supports 60, 1440 (1 day), 4320 (3 days), 10080 (1 week). Default: 60. */
+	autoArchiveDuration: z.union([
+		z.enum([
+			"60",
+			"1440",
+			"4320",
+			"10080"
+		]),
+		z.literal(60),
+		z.literal(1440),
+		z.literal(4320),
+		z.literal(10080)
+	]).optional()
+}, { omit: ["allowFrom"] });
+const DiscordGuildSchema = buildGroupEntrySchema({
+	slug: z.string().optional(),
+	ignoreOtherMentions: z.boolean().optional(),
+	...buildChannelReactionShape({ notificationModes: [
+		"off",
+		"own",
+		"all",
+		"allowlist"
+	] }),
+	users: DiscordIdListSchema.optional(),
+	roles: DiscordIdListSchema.optional(),
+	presenceEvents: DiscordPresenceEventsSchema.optional(),
+	channels: z.record(z.string(), DiscordGuildChannelSchema.optional()).optional()
+}, { omit: [
+	"enabled",
+	"skills",
+	"allowFrom",
+	"systemPrompt"
+] });
+const DiscordVoiceAutoJoinSchema = z.object({
+	guildId: z.string().min(1),
+	channelId: z.string().min(1),
+	whenOccupied: z.boolean().optional()
+}).strict();
+const DiscordVoiceAllowedChannelSchema = z.object({
+	guildId: z.string().min(1),
+	channelId: z.string().min(1)
+}).strict();
+const DiscordVoiceRealtimeToolPolicySchema = z.enum([
+	"safe-read-only",
+	"owner",
+	"none"
+]);
+const DiscordVoiceRealtimeConsultPolicySchema = z.enum(["auto", "always"]);
+const DiscordVoiceRealtimeBootstrapContextFileSchema = z.enum([
+	"IDENTITY.md",
+	"USER.md",
+	"SOUL.md"
+]);
+const DiscordVoiceRealtimeWakeNameSchema = z.string().min(1).regex(/^\s*[^a-z0-9]*[a-z0-9]+(?:[^a-z0-9]+[a-z0-9]+)?[^a-z0-9]*\s*$/i, { message: "Discord realtime wake names must be one or two words." });
+const DiscordVoiceRealtimeSchema = z.object({
+	provider: z.string().min(1).optional(),
+	model: z.string().min(1).optional(),
+	speakerVoice: z.string().min(1).optional(),
+	speakerVoiceId: z.string().min(1).optional(),
+	instructions: z.string().min(1).optional(),
+	toolPolicy: DiscordVoiceRealtimeToolPolicySchema.optional(),
+	consultPolicy: DiscordVoiceRealtimeConsultPolicySchema.optional(),
+	requireWakeName: z.boolean().optional(),
+	wakeNames: z.array(DiscordVoiceRealtimeWakeNameSchema).min(1).optional(),
+	bootstrapContextFiles: z.array(DiscordVoiceRealtimeBootstrapContextFileSchema).optional(),
+	bargeIn: z.boolean().optional(),
+	minBargeInAudioEndMs: z.number().int().min(0).max(1e4).optional(),
+	debounceMs: z.number().int().positive().max(1e4).optional(),
+	providers: z.record(z.string(), z.record(z.string(), z.unknown()).optional()).optional()
+}).strict();
+const DiscordVoiceAgentSessionSchema = z.object({
+	mode: z.enum(["voice", "target"]).optional(),
+	target: z.string().min(1).optional()
+}).strict().superRefine((value, ctx) => {
+	if (value.mode === "target" && !value.target) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["target"],
+		message: "voice.agentSession.target is required when mode is \"target\""
+	});
+});
+const DiscordVoiceSchema = z.object({
+	enabled: z.boolean().optional(),
+	mode: z.enum([
+		"stt-tts",
+		"agent-proxy",
+		"bidi"
+	]).optional(),
+	agentSession: DiscordVoiceAgentSessionSchema.optional(),
+	model: z.string().min(1).optional(),
+	realtime: DiscordVoiceRealtimeSchema.optional(),
+	autoJoin: z.array(DiscordVoiceAutoJoinSchema).optional(),
+	followUsersEnabled: z.boolean().optional(),
+	followUsers: z.array(z.string().min(1)).optional(),
+	allowedChannels: z.array(DiscordVoiceAllowedChannelSchema).optional(),
+	daveEncryption: z.boolean().optional(),
+	decryptionFailureTolerance: z.number().int().min(0).optional(),
+	connectTimeoutMs: z.number().int().positive().max(12e4).optional(),
+	reconnectGraceMs: z.number().int().positive().max(12e4).optional(),
+	captureSilenceGraceMs: z.number().int().positive().max(3e4).optional(),
+	tts: TtsConfigSchema.optional()
+}).strict().optional();
+const { accountShape, rootPolicyShape } = buildChannelAccountSchemaParts({
+	omit: ["groupAllowFrom"],
+	allowFrom: DiscordIdListSchema.optional(),
+	streaming: DiscordPreviewStreamingConfigSchema.optional()
+});
+const DiscordAccountSchemaBase = z.object({
+	...accountShape,
+	joinIntro: z.boolean().optional(),
+	commands: ProviderCommandsSchema,
+	token: registerSensitiveConfigSchema(SecretInputSchema.optional()),
+	applicationId: DiscordIdSchema.optional(),
+	activities: z.object({
+		clientSecret: registerSensitiveConfigSchema(z.string().min(1).optional()),
+		applicationId: DiscordSnowflakeStringSchema.optional()
+	}).strict().optional(),
+	proxy: z.string().optional(),
+	allowBots: buildChannelAllowBotsSchema({ allowMentions: true }),
+	botLoopProtection: ChannelBotLoopProtectionSchema.optional(),
+	dangerouslyAllowNameMatching: ChannelDangerouslyAllowNameMatchingSchema,
+	mentionAliases: z.record(z.string(), DiscordSnowflakeStringSchema).optional(),
+	suppressEmbeds: z.boolean().optional(),
+	maxLinesPerMessage: z.number().int().positive().optional(),
+	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(),
+	thread: DiscordThreadSchema.optional(),
+	dm: DiscordDmSchema.optional(),
+	guilds: z.record(z.string(), DiscordGuildSchema.optional()).optional(),
+	execApprovals: buildChannelExecApprovalsSchema(DiscordIdSchema, { cleanupAfterResolve: z.boolean().optional() }),
+	agentComponents: z.object({
+		enabled: z.boolean().optional(),
+		ttlMs: z.number().int().positive().max(864e5).optional()
+	}).strict().optional(),
+	slashCommand: z.object({ ephemeral: z.boolean().optional() }).strict().optional(),
+	threadBindings: z.object({
+		enabled: z.boolean().optional(),
+		idleHours: z.number().nonnegative().optional(),
+		maxAgeHours: z.number().nonnegative().optional(),
+		spawnSessions: z.boolean().optional(),
+		defaultSpawnContext: z.enum(["isolated", "fork"]).optional()
+	}).strict().optional(),
+	intents: z.object({
+		messageContent: z.boolean().optional(),
+		presence: z.boolean().optional(),
+		guildMembers: z.boolean().optional(),
+		voiceStates: z.boolean().optional()
+	}).strict().optional(),
+	voice: DiscordVoiceSchema,
+	pluralkit: z.object({
+		enabled: z.boolean().optional(),
+		token: registerSensitiveConfigSchema(SecretInputSchema.optional())
+	}).strict().optional(),
+	...buildChannelReactionShape({ ackReaction: z.string().optional() }),
+	ackReactionScope: z.enum([
+		"group-mentions",
+		"group-all",
+		"direct",
+		"all",
+		"off",
+		"none"
+	]).optional(),
+	activity: z.string().optional(),
+	status: z.enum([
+		"online",
+		"dnd",
+		"idle",
+		"invisible"
+	]).optional(),
+	autoPresence: z.object({
+		enabled: z.boolean().optional(),
+		intervalMs: z.number().int().positive().optional(),
+		minUpdateIntervalMs: z.number().int().positive().optional()
+	}).strict().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(),
+	inboundWorker: z.object({ runTimeoutMs: z.number().int().nonnegative().optional() }).strict().optional()
+}).strict().superRefine((value, ctx) => {
+	const activityText = normalizeOptionalString(value.activity) ?? "";
+	const hasActivity = Boolean(activityText);
+	const hasActivityType = value.activityType !== void 0;
+	const activityUrl = normalizeOptionalString(value.activityUrl) ?? "";
+	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 autoPresenceInterval = value.autoPresence?.intervalMs;
+	const autoPresenceMinUpdate = value.autoPresence?.minUpdateIntervalMs;
+	if (typeof autoPresenceInterval === "number" && typeof autoPresenceMinUpdate === "number" && autoPresenceMinUpdate > autoPresenceInterval) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "channels.discord.autoPresence.minUpdateIntervalMs must be less than or equal to channels.discord.autoPresence.intervalMs",
+		path: ["autoPresence", "minUpdateIntervalMs"]
+	});
+});
+function normalizeShippedDiscordDmAliases(value) {
+	const entry = asObjectRecord(value);
+	if (!entry) return value;
+	const updated = normalizeLegacyDmAliases({
+		entry,
+		pathPrefix: "channels.discord",
+		changes: []
+	}).entry;
+	const dm = asObjectRecord(updated.dm);
+	if (!dm || dm.policy === void 0 && dm.allowFrom === void 0) return updated;
+	const { policy: _policy, allowFrom: _allowFrom, ...retainedDm } = dm;
+	const { dm: _dm, ...rest } = updated;
+	return Object.keys(retainedDm).length > 0 ? {
+		...rest,
+		dm: retainedDm
+	} : rest;
+}
+const DiscordAccountSchema = z.preprocess(normalizeShippedDiscordDmAliases, DiscordAccountSchemaBase);
+const DiscordConfigSchemaBase = DiscordAccountSchemaBase.safeExtend({
+	...rootPolicyShape,
+	accounts: z.record(z.string(), DiscordAccountSchema.optional()).optional(),
+	defaultAccount: z.string().optional()
+}).superRefine((value, ctx) => {
+	const dmPolicy = value.dmPolicy ?? "pairing";
+	const allowFrom = value.allowFrom;
+	requireOpenAllowFrom({
+		policy: dmPolicy,
+		allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.discord.dmPolicy=\"open\" requires channels.discord.allowFrom to include \"*\""
+	});
+	requireAllowlistAllowFrom({
+		policy: dmPolicy,
+		allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.discord.dmPolicy=\"allowlist\" requires channels.discord.allowFrom to contain at least one sender ID"
+	});
+	if (!value.accounts) return;
+	for (const [accountId, account] of Object.entries(value.accounts)) {
+		if (!account) continue;
+		const effectivePolicy = account.dmPolicy ?? value.dmPolicy ?? "pairing";
+		const effectiveAllowFrom = account.allowFrom ?? value.allowFrom;
+		requireOpenAllowFrom({
+			policy: effectivePolicy,
+			allowFrom: effectiveAllowFrom,
+			ctx,
+			path: [
+				"accounts",
+				accountId,
+				"allowFrom"
+			],
+			message: "channels.discord.accounts.*.dmPolicy=\"open\" requires channels.discord.accounts.*.allowFrom (or channels.discord.allowFrom) to include \"*\""
+		});
+		requireAllowlistAllowFrom({
+			policy: effectivePolicy,
+			allowFrom: effectiveAllowFrom,
+			ctx,
+			path: [
+				"accounts",
+				accountId,
+				"allowFrom"
+			],
+			message: "channels.discord.accounts.*.dmPolicy=\"allowlist\" requires channels.discord.accounts.*.allowFrom (or channels.discord.allowFrom) to contain at least one sender ID"
+		});
+	}
+});
+const DiscordConfigSchema = z.preprocess(normalizeShippedDiscordDmAliases, DiscordConfigSchemaBase);
+const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema, { uiHints: discordChannelConfigUiHints });
+//#endregion
+export { DiscordChannelConfigSchema as t };