@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/zod-schema.providers-core-CX8AFeyJ.js

@@ -0,0 +1,1354 @@
+import { s as normalizeOptionalString } from "./string-coerce-BUSzWgUA.js";
+import { a as hasConfiguredSecretInput } from "./types.secrets-C9RpLzA0.js";
+import { n as BlockStreamingCoalesceSchema, t as BlockStreamingChunkSchema, l as GroupPolicySchema, o as DmPolicySchema, S as RetryConfigSchema, v as ProviderCommandsSchema, h as MarkdownConfigSchema, C as SecretInputSchema, a as DmConfigSchema, i as ContextVisibilityModeSchema, x as ReplyToModeSchema, I as requireOpenAllowFrom, F as requireAllowlistAllowFrom, u as HexColorSchema, j as TtsConfigSchema, T as SecretRefSchema, s as ExecutableTokenSchema, m as MSTeamsReplyStyleSchema } from "./zod-schema.core-BrzjtZhM.js";
+import { t as sensitive } from "./zod-schema.sensitive-BFZ4qze6.js";
+import { s as ToolPolicySchema } from "./zod-schema.agent-runtime-D48J52r_.js";
+import { t as isSafeScpRemoteHost } from "./scp-host-CiFVRWHy.js";
+import { n as isValidInboundPathRootPattern } from "./inbound-path-policy-CQkSSeSi.js";
+import { r as normalizeTelegramCommandDescription, i as normalizeTelegramCommandName, a as resolveTelegramCustomCommands } from "./telegram-command-config-TdpOuZ__.js";
+import { z } from "zod";
+const ChannelHeartbeatVisibilitySchema = z.object({
+  showOk: z.boolean().optional(),
+  showAlerts: z.boolean().optional(),
+  useIndicator: z.boolean().optional()
+}).strict().optional();
+const ChannelHealthMonitorSchema = z.object({ enabled: z.boolean().optional() }).strict().optional();
+function forEachEnabledAccount(accounts, run) {
+  if (!accounts) return;
+  for (const [accountId, account] of Object.entries(accounts)) {
+    if (!account || account.enabled === false) continue;
+    run(accountId, account);
+  }
+}
+function validateTelegramWebhookSecretRequirements(value, ctx) {
+  const baseWebhookUrl = normalizeOptionalString(value.webhookUrl) ?? "";
+  const hasBaseWebhookSecret = hasConfiguredSecretInput(value.webhookSecret);
+  if (baseWebhookUrl && !hasBaseWebhookSecret) ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    message: "channels.telegram.webhookUrl requires channels.telegram.webhookSecret",
+    path: ["webhookSecret"]
+  });
+  forEachEnabledAccount(value.accounts, (accountId, account) => {
+    if (!(normalizeOptionalString(account.webhookUrl) ?? "")) return;
+    if (!hasConfiguredSecretInput(account.webhookSecret) && !hasBaseWebhookSecret) ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "channels.telegram.accounts.*.webhookUrl requires channels.telegram.webhookSecret or channels.telegram.accounts.*.webhookSecret",
+      path: [
+        "accounts",
+        accountId,
+        "webhookSecret"
+      ]
+    });
+  });
+}
+function validateSlackSigningSecretRequirements(value, ctx) {
+  const baseMode = value.mode === "http" || value.mode === "socket" ? value.mode : "socket";
+  if (baseMode === "http" && !hasConfiguredSecretInput(value.signingSecret)) ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    message: 'channels.slack.mode="http" requires channels.slack.signingSecret',
+    path: ["signingSecret"]
+  });
+  forEachEnabledAccount(value.accounts, (accountId, account) => {
+    if ((account.mode === "http" || account.mode === "socket" ? account.mode : baseMode) !== "http") return;
+    if (!hasConfiguredSecretInput(account.signingSecret ?? value.signingSecret)) 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"
+      ]
+    });
+  });
+}
+const ToolPolicyBySenderSchema = z.record(z.string(), ToolPolicySchema).optional();
+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 TelegramInlineButtonsScopeSchema = z.enum([
+  "off",
+  "dm",
+  "group",
+  "all",
+  "allowlist"
+]);
+const TelegramIdListSchema = z.array(z.union([z.string(), z.number()]));
+const TelegramCapabilitiesSchema = z.union([z.array(z.string()), z.object({ inlineButtons: TelegramInlineButtonsScopeSchema.optional() }).strict()]);
+const TextChunkModeSchema = z.enum(["length", "newline"]);
+const UnifiedStreamingModeSchema = z.enum([
+  "off",
+  "partial",
+  "block",
+  "progress"
+]);
+const ChannelStreamingBlockSchema = z.object({
+  enabled: z.boolean().optional(),
+  coalesce: BlockStreamingCoalesceSchema.optional()
+}).strict();
+const ChannelStreamingPreviewSchema = z.object({ chunk: BlockStreamingChunkSchema.optional() }).strict();
+const ChannelPreviewStreamingConfigSchema = z.object({
+  mode: UnifiedStreamingModeSchema.optional(),
+  chunkMode: TextChunkModeSchema.optional(),
+  preview: ChannelStreamingPreviewSchema.optional(),
+  block: ChannelStreamingBlockSchema.optional()
+}).strict();
+const SlackStreamingConfigSchema = ChannelPreviewStreamingConfigSchema.extend({ nativeTransport: z.boolean().optional() }).strict();
+const SlackCapabilitiesSchema = z.union([z.array(z.string()), z.object({ interactiveReplies: z.boolean().optional() }).strict()]);
+const TelegramErrorPolicySchema = z.enum([
+  "always",
+  "once",
+  "silent"
+]).optional();
+const TelegramTopicSchema = z.object({
+  requireMention: z.boolean().optional(),
+  ingest: z.boolean().optional(),
+  disableAudioPreflight: 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(),
+  systemPrompt: z.string().optional(),
+  agentId: z.string().optional(),
+  errorPolicy: TelegramErrorPolicySchema,
+  errorCooldownMs: z.number().int().nonnegative().optional()
+}).strict();
+const TelegramGroupSchema = z.object({
+  requireMention: z.boolean().optional(),
+  ingest: z.boolean().optional(),
+  disableAudioPreflight: z.boolean().optional(),
+  groupPolicy: GroupPolicySchema.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(),
+  errorPolicy: TelegramErrorPolicySchema,
+  errorCooldownMs: z.number().int().nonnegative().optional()
+}).strict();
+const AutoTopicLabelSchema = z.union([z.boolean(), z.object({
+  enabled: z.boolean().optional(),
+  prompt: z.string().optional()
+}).strict()]).optional();
+const TelegramDirectSchema = z.object({
+  dmPolicy: DmPolicySchema.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(),
+  errorPolicy: TelegramErrorPolicySchema,
+  errorCooldownMs: z.number().int().nonnegative().optional(),
+  requireTopic: z.boolean().optional(),
+  autoTopicLabel: AutoTopicLabelSchema
+}).strict();
+const TelegramCustomCommandSchema = z.object({
+  command: z.string().overwrite(normalizeTelegramCommandName),
+  description: z.string().overwrite(normalizeTelegramCommandDescription)
+}).strict();
+const validateTelegramCustomCommands = (value, ctx) => {
+  if (!value.customCommands || value.customCommands.length === 0) return;
+  const { issues } = resolveTelegramCustomCommands({
+    commands: value.customCommands
+  });
+  for (const issue of issues) ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    path: [
+      "customCommands",
+      issue.index,
+      issue.field
+    ],
+    message: issue.message
+  });
+};
+const TelegramAccountSchemaBase = z.object({
+  name: z.string().optional(),
+  capabilities: TelegramCapabilitiesSchema.optional(),
+  execApprovals: z.object({
+    enabled: z.boolean().optional(),
+    approvers: TelegramIdListSchema.optional(),
+    agentFilter: z.array(z.string()).optional(),
+    sessionFilter: z.array(z.string()).optional(),
+    target: z.enum([
+      "dm",
+      "channel",
+      "both"
+    ]).optional()
+  }).strict().optional(),
+  markdown: MarkdownConfigSchema,
+  enabled: z.boolean().optional(),
+  commands: ProviderCommandsSchema,
+  customCommands: z.array(TelegramCustomCommandSchema).optional(),
+  configWrites: z.boolean().optional(),
+  dmPolicy: DmPolicySchema.optional().default("pairing"),
+  botToken: SecretInputSchema.optional().register(sensitive),
+  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(),
+  defaultTo: z.union([z.string(), z.number()]).optional(),
+  groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  contextVisibility: ContextVisibilityModeSchema.optional(),
+  historyLimit: z.number().int().min(0).optional(),
+  dmHistoryLimit: z.number().int().min(0).optional(),
+  dms: z.record(z.string(), DmConfigSchema.optional()).optional(),
+  direct: z.record(z.string(), TelegramDirectSchema.optional()).optional(),
+  textChunkLimit: z.number().int().positive().optional(),
+  streaming: ChannelPreviewStreamingConfigSchema.optional(),
+  mediaMaxMb: z.number().positive().optional(),
+  timeoutSeconds: z.number().int().positive().optional(),
+  retry: RetryConfigSchema,
+  network: z.object({
+    autoSelectFamily: z.boolean().optional(),
+    dnsResultOrder: z.enum(["ipv4first", "verbatim"]).optional(),
+    dangerouslyAllowPrivateNetwork: z.boolean().optional().describe("Dangerous opt-in for trusted Telegram fake-IP or transparent-proxy environments where api.telegram.org resolves to private/internal/special-use addresses during media downloads.")
+  }).strict().optional(),
+  proxy: z.string().optional(),
+  webhookUrl: z.string().optional().describe("Public HTTPS webhook URL registered with Telegram for inbound updates. This must be internet-reachable and requires channels.telegram.webhookSecret."),
+  webhookSecret: SecretInputSchema.optional().describe("Secret token sent to Telegram during webhook registration and verified on inbound webhook requests. Telegram returns this value for verification; this is not the gateway auth token and not the bot token.").register(sensitive),
+  webhookPath: z.string().optional().describe("Local webhook route path served by the gateway listener. Defaults to /telegram-webhook."),
+  webhookHost: z.string().optional().describe("Local bind host for the webhook listener. Defaults to 127.0.0.1; keep loopback unless you intentionally expose direct ingress."),
+  webhookPort: z.number().int().nonnegative().optional().describe("Local bind port for the webhook listener. Defaults to 8787; set to 0 to let the OS assign an ephemeral port."),
+  webhookCertPath: z.string().optional().describe("Path to the self-signed certificate (PEM) to upload to Telegram during webhook registration. Required for self-signed certs (direct IP or no domain)."),
+  actions: z.object({
+    reactions: z.boolean().optional(),
+    sendMessage: z.boolean().optional(),
+    poll: z.boolean().optional(),
+    deleteMessage: z.boolean().optional(),
+    editMessage: z.boolean().optional(),
+    sticker: z.boolean().optional(),
+    createForumTopic: z.boolean().optional(),
+    editForumTopic: z.boolean().optional()
+  }).strict().optional(),
+  threadBindings: z.object({
+    enabled: z.boolean().optional(),
+    idleHours: z.number().nonnegative().optional(),
+    maxAgeHours: z.number().nonnegative().optional(),
+    spawnSubagentSessions: z.boolean().optional(),
+    spawnAcpSessions: z.boolean().optional()
+  }).strict().optional(),
+  reactionNotifications: z.enum([
+    "off",
+    "own",
+    "all"
+  ]).optional(),
+  reactionLevel: z.enum([
+    "off",
+    "ack",
+    "minimal",
+    "extensive"
+  ]).optional(),
+  heartbeat: ChannelHeartbeatVisibilitySchema,
+  healthMonitor: ChannelHealthMonitorSchema,
+  linkPreview: z.boolean().optional(),
+  silentErrorReplies: z.boolean().optional(),
+  responsePrefix: z.string().optional(),
+  ackReaction: z.string().optional(),
+  errorPolicy: TelegramErrorPolicySchema,
+  errorCooldownMs: z.number().int().nonnegative().optional(),
+  apiRoot: z.string().url().optional(),
+  trustedLocalFileRoots: z.array(z.string()).optional().describe("Trusted local filesystem roots for self-hosted Telegram Bot API absolute file_path values. Only absolute paths under these roots are read directly; all other absolute paths are rejected."),
+  autoTopicLabel: AutoTopicLabelSchema
+}).strict();
+const TelegramAccountSchema = TelegramAccountSchemaBase.superRefine((value, ctx) => {
+  validateTelegramCustomCommands(value, ctx);
+});
+TelegramAccountSchemaBase.extend({
+  accounts: z.record(z.string(), TelegramAccountSchema.optional()).optional(),
+  defaultAccount: z.string().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 "*"'
+  });
+  requireAllowlistAllowFrom({
+    policy: value.dmPolicy,
+    allowFrom: value.allowFrom,
+    ctx,
+    path: ["allowFrom"],
+    message: 'channels.telegram.dmPolicy="allowlist" requires channels.telegram.allowFrom to contain at least one sender ID'
+  });
+  validateTelegramCustomCommands(value, ctx);
+  if (value.accounts) for (const [accountId, account] of Object.entries(value.accounts)) {
+    if (!account) continue;
+    const effectivePolicy = account.dmPolicy ?? value.dmPolicy;
+    const effectiveAllowFrom = account.allowFrom ?? value.allowFrom;
+    requireOpenAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.telegram.accounts.*.dmPolicy="open" requires channels.telegram.accounts.*.allowFrom (or channels.telegram.allowFrom) to include "*"'
+    });
+    requireAllowlistAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.telegram.accounts.*.dmPolicy="allowlist" requires channels.telegram.accounts.*.allowFrom (or channels.telegram.allowFrom) to contain at least one sender ID'
+    });
+  }
+  if (!value.accounts) {
+    validateTelegramWebhookSecretRequirements(value, ctx);
+    return;
+  }
+  for (const [accountId, account] of Object.entries(value.accounts)) {
+    if (!account) continue;
+    if (account.enabled === false) continue;
+    const effectiveDmPolicy = account.dmPolicy ?? value.dmPolicy;
+    const effectiveAllowFrom = Array.isArray(account.allowFrom) ? account.allowFrom : value.allowFrom;
+    requireOpenAllowFrom({
+      policy: effectiveDmPolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.telegram.accounts.*.dmPolicy="open" requires channels.telegram.allowFrom or channels.telegram.accounts.*.allowFrom to include "*"'
+    });
+    requireAllowlistAllowFrom({
+      policy: effectiveDmPolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.telegram.accounts.*.dmPolicy="allowlist" requires channels.telegram.allowFrom or channels.telegram.accounts.*.allowFrom to contain at least one sender ID'
+    });
+  }
+  validateTelegramWebhookSecretRequirements(value, ctx);
+});
+const DiscordDmSchema = z.object({
+  enabled: z.boolean().optional(),
+  policy: DmPolicySchema.optional(),
+  allowFrom: DiscordIdListSchema.optional(),
+  groupEnabled: z.boolean().optional(),
+  groupChannels: DiscordIdListSchema.optional()
+}).strict();
+const DiscordGuildChannelSchema = z.object({
+  requireMention: z.boolean().optional(),
+  ignoreOtherMentions: z.boolean().optional(),
+  tools: ToolPolicySchema,
+  toolsBySender: ToolPolicyBySenderSchema,
+  skills: z.array(z.string()).optional(),
+  enabled: z.boolean().optional(),
+  users: DiscordIdListSchema.optional(),
+  roles: DiscordIdListSchema.optional(),
+  systemPrompt: z.string().optional(),
+  includeThreadStarter: z.boolean().optional(),
+  autoThread: z.boolean().optional(),
+  autoThreadName: z.enum(["message", "generated"]).optional(),
+  autoArchiveDuration: z.union([
+    z.enum([
+      "60",
+      "1440",
+      "4320",
+      "10080"
+    ]),
+    z.literal(60),
+    z.literal(1440),
+    z.literal(4320),
+    z.literal(10080)
+  ]).optional()
+}).strict();
+const DiscordGuildSchema = z.object({
+  slug: z.string().optional(),
+  requireMention: z.boolean().optional(),
+  ignoreOtherMentions: z.boolean().optional(),
+  tools: ToolPolicySchema,
+  toolsBySender: ToolPolicyBySenderSchema,
+  reactionNotifications: z.enum([
+    "off",
+    "own",
+    "all",
+    "allowlist"
+  ]).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();
+const DiscordVoiceAutoJoinSchema = z.object({
+  guildId: z.string().min(1),
+  channelId: z.string().min(1)
+}).strict();
+const DiscordVoiceSchema = z.object({
+  enabled: z.boolean().optional(),
+  autoJoin: z.array(DiscordVoiceAutoJoinSchema).optional(),
+  daveEncryption: z.boolean().optional(),
+  decryptionFailureTolerance: z.number().int().min(0).optional(),
+  tts: TtsConfigSchema.optional()
+}).strict().optional();
+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: SecretInputSchema.optional().register(sensitive),
+  proxy: z.string().optional(),
+  allowBots: z.union([z.boolean(), z.literal("mentions")]).optional(),
+  dangerouslyAllowNameMatching: z.boolean().optional(),
+  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  contextVisibility: ContextVisibilityModeSchema.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(),
+  streaming: ChannelPreviewStreamingConfigSchema.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(),
+  dmPolicy: DmPolicySchema.optional(),
+  allowFrom: DiscordIdListSchema.optional(),
+  defaultTo: z.string().optional(),
+  dm: DiscordDmSchema.optional(),
+  guilds: z.record(z.string(), DiscordGuildSchema.optional()).optional(),
+  heartbeat: ChannelHeartbeatVisibilitySchema,
+  healthMonitor: ChannelHealthMonitorSchema,
+  execApprovals: z.object({
+    enabled: z.boolean().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(),
+  agentComponents: z.object({ enabled: z.boolean().optional() }).strict().optional(),
+  ui: DiscordUiSchema,
+  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(),
+    spawnSubagentSessions: z.boolean().optional(),
+    spawnAcpSessions: z.boolean().optional()
+  }).strict().optional(),
+  intents: z.object({
+    presence: z.boolean().optional(),
+    guildMembers: z.boolean().optional()
+  }).strict().optional(),
+  voice: DiscordVoiceSchema,
+  pluralkit: z.object({
+    enabled: z.boolean().optional(),
+    token: SecretInputSchema.optional().register(sensitive)
+  }).strict().optional(),
+  responsePrefix: z.string().optional(),
+  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(),
+    healthyText: z.string().optional(),
+    degradedText: z.string().optional(),
+    exhaustedText: z.string().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(),
+  eventQueue: z.object({
+    listenerTimeout: z.number().int().positive().optional(),
+    maxQueueSize: z.number().int().positive().optional(),
+    maxConcurrency: z.number().int().positive().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"]
+  });
+});
+DiscordAccountSchema.extend({
+  accounts: z.record(z.string(), DiscordAccountSchema.optional()).optional(),
+  defaultAccount: z.string().optional()
+}).superRefine((value, ctx) => {
+  const dmPolicy = value.dmPolicy ?? value.dm?.policy ?? "pairing";
+  const allowFrom = value.allowFrom ?? value.dm?.allowFrom;
+  const allowFromPath = value.allowFrom !== void 0 ? ["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 "*"'
+  });
+  requireAllowlistAllowFrom({
+    policy: dmPolicy,
+    allowFrom,
+    ctx,
+    path: [...allowFromPath],
+    message: 'channels.discord.dmPolicy="allowlist" requires channels.discord.allowFrom (or channels.discord.dm.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 ?? account.dm?.policy ?? value.dmPolicy ?? value.dm?.policy ?? "pairing";
+    const effectiveAllowFrom = account.allowFrom ?? account.dm?.allowFrom ?? value.allowFrom ?? value.dm?.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 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 "*"'
+  });
+  requireAllowlistAllowFrom({
+    policy: value.policy,
+    allowFrom: value.allowFrom,
+    ctx,
+    path: ["allowFrom"],
+    message: 'channels.googlechat.dm.policy="allowlist" requires channels.googlechat.dm.allowFrom to contain at least one sender ID'
+  });
+});
+const GoogleChatGroupSchema = z.object({
+  enabled: z.boolean().optional(),
+  requireMention: z.boolean().optional(),
+  users: z.array(z.union([z.string(), z.number()])).optional(),
+  systemPrompt: z.string().optional()
+}).strict();
+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(),
+  dangerouslyAllowNameMatching: 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(),
+  defaultTo: z.string().optional(),
+  serviceAccount: z.union([
+    z.string(),
+    z.record(z.string(), z.unknown()),
+    SecretRefSchema
+  ]).optional().register(sensitive),
+  serviceAccountRef: SecretRefSchema.optional().register(sensitive),
+  serviceAccountFile: z.string().optional(),
+  audienceType: z.enum(["app-url", "project-number"]).optional(),
+  audience: z.string().optional(),
+  appPrincipal: 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(),
+  healthMonitor: ChannelHealthMonitorSchema,
+  typingIndicator: z.enum([
+    "none",
+    "message",
+    "reaction"
+  ]).optional(),
+  responsePrefix: z.string().optional()
+}).strict();
+GoogleChatAccountSchema.extend({
+  accounts: z.record(z.string(), GoogleChatAccountSchema.optional()).optional(),
+  defaultAccount: z.string().optional()
+});
+const SlackDmSchema = z.object({
+  enabled: z.boolean().optional(),
+  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();
+const SlackChannelSchema = z.object({
+  enabled: 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();
+const SlackThreadSchema = z.object({
+  historyScope: z.enum(["thread", "channel"]).optional(),
+  inheritParent: z.boolean().optional(),
+  initialHistoryLimit: z.number().int().min(0).optional(),
+  requireExplicitMention: z.boolean().optional()
+}).strict();
+const SlackReplyToModeByChatTypeSchema = z.object({
+  direct: ReplyToModeSchema.optional(),
+  group: ReplyToModeSchema.optional(),
+  channel: ReplyToModeSchema.optional()
+}).strict();
+const SlackAccountSchema = z.object({
+  name: z.string().optional(),
+  mode: z.enum(["socket", "http"]).optional(),
+  signingSecret: SecretInputSchema.optional().register(sensitive),
+  webhookPath: z.string().optional(),
+  capabilities: SlackCapabilitiesSchema.optional(),
+  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(),
+    target: z.enum([
+      "dm",
+      "channel",
+      "both"
+    ]).optional()
+  }).strict().optional(),
+  markdown: MarkdownConfigSchema,
+  enabled: z.boolean().optional(),
+  commands: ProviderCommandsSchema,
+  configWrites: z.boolean().optional(),
+  botToken: SecretInputSchema.optional().register(sensitive),
+  appToken: SecretInputSchema.optional().register(sensitive),
+  userToken: SecretInputSchema.optional().register(sensitive),
+  userTokenReadOnly: z.boolean().optional().default(true),
+  allowBots: z.boolean().optional(),
+  dangerouslyAllowNameMatching: z.boolean().optional(),
+  requireMention: z.boolean().optional(),
+  groupPolicy: GroupPolicySchema.optional(),
+  contextVisibility: ContextVisibilityModeSchema.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(),
+  streaming: SlackStreamingConfigSchema.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(),
+  dmPolicy: DmPolicySchema.optional(),
+  allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  defaultTo: z.string().optional(),
+  dm: SlackDmSchema.optional(),
+  channels: z.record(z.string(), SlackChannelSchema.optional()).optional(),
+  heartbeat: ChannelHeartbeatVisibilitySchema,
+  healthMonitor: ChannelHealthMonitorSchema,
+  responsePrefix: z.string().optional(),
+  ackReaction: z.string().optional(),
+  typingReaction: z.string().optional()
+}).strict().superRefine(() => {
+});
+SlackAccountSchema.safeExtend({
+  mode: z.enum(["socket", "http"]).optional().default("socket"),
+  signingSecret: SecretInputSchema.optional().register(sensitive),
+  webhookPath: z.string().optional().default("/slack/events"),
+  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  contextVisibility: ContextVisibilityModeSchema.optional(),
+  accounts: z.record(z.string(), SlackAccountSchema.optional()).optional(),
+  defaultAccount: z.string().optional()
+}).superRefine((value, ctx) => {
+  const dmPolicy = value.dmPolicy ?? value.dm?.policy ?? "pairing";
+  const allowFrom = value.allowFrom ?? value.dm?.allowFrom;
+  const allowFromPath = value.allowFrom !== void 0 ? ["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 "*"'
+  });
+  requireAllowlistAllowFrom({
+    policy: dmPolicy,
+    allowFrom,
+    ctx,
+    path: [...allowFromPath],
+    message: 'channels.slack.dmPolicy="allowlist" requires channels.slack.allowFrom (or channels.slack.dm.allowFrom) to contain at least one sender ID'
+  });
+  const baseMode = value.mode ?? "socket";
+  if (!value.accounts) {
+    validateSlackSigningSecretRequirements(value, ctx);
+    return;
+  }
+  for (const [accountId, account] of Object.entries(value.accounts)) {
+    if (!account) continue;
+    if (account.enabled === false) continue;
+    const accountMode = account.mode ?? baseMode;
+    const effectivePolicy = account.dmPolicy ?? account.dm?.policy ?? value.dmPolicy ?? value.dm?.policy ?? "pairing";
+    const effectiveAllowFrom = account.allowFrom ?? account.dm?.allowFrom ?? value.allowFrom ?? value.dm?.allowFrom;
+    requireOpenAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.slack.accounts.*.dmPolicy="open" requires channels.slack.accounts.*.allowFrom (or channels.slack.allowFrom) to include "*"'
+    });
+    requireAllowlistAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.slack.accounts.*.dmPolicy="allowlist" requires channels.slack.accounts.*.allowFrom (or channels.slack.allowFrom) to contain at least one sender ID'
+    });
+    if (accountMode !== "http") continue;
+  }
+  validateSlackSigningSecretRequirements(value, ctx);
+});
+const SignalGroupEntrySchema = z.object({
+  requireMention: z.boolean().optional(),
+  ingest: z.boolean().optional(),
+  tools: ToolPolicySchema,
+  toolsBySender: ToolPolicyBySenderSchema
+}).strict();
+const SignalGroupsSchema = z.record(z.string(), SignalGroupEntrySchema.optional()).optional();
+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(),
+  accountUuid: 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(1e3).max(12e4).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(),
+  defaultTo: z.string().optional(),
+  groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  contextVisibility: ContextVisibilityModeSchema.optional(),
+  groups: SignalGroupsSchema,
+  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,
+  healthMonitor: ChannelHealthMonitorSchema,
+  responsePrefix: z.string().optional()
+}).strict();
+const SignalAccountSchema = SignalAccountSchemaBase;
+SignalAccountSchemaBase.extend({
+  accounts: z.record(z.string(), SignalAccountSchema.optional()).optional(),
+  defaultAccount: z.string().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 "*"'
+  });
+  requireAllowlistAllowFrom({
+    policy: value.dmPolicy,
+    allowFrom: value.allowFrom,
+    ctx,
+    path: ["allowFrom"],
+    message: 'channels.signal.dmPolicy="allowlist" requires channels.signal.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;
+    const effectiveAllowFrom = account.allowFrom ?? value.allowFrom;
+    requireOpenAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.signal.accounts.*.dmPolicy="open" requires channels.signal.accounts.*.allowFrom (or channels.signal.allowFrom) to include "*"'
+    });
+    requireAllowlistAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.signal.accounts.*.dmPolicy="allowlist" requires channels.signal.accounts.*.allowFrom (or channels.signal.allowFrom) to contain at least one sender ID'
+    });
+  }
+});
+const IrcGroupSchema = 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()
+}).strict();
+const IrcNickServSchema = z.object({
+  enabled: z.boolean().optional(),
+  service: z.string().optional(),
+  password: SecretInputSchema.optional().register(sensitive),
+  passwordFile: z.string().optional(),
+  register: z.boolean().optional(),
+  registerEmail: z.string().optional()
+}).strict();
+const IrcAccountSchemaBase = z.object({
+  name: z.string().optional(),
+  capabilities: z.array(z.string()).optional(),
+  markdown: MarkdownConfigSchema,
+  enabled: z.boolean().optional(),
+  configWrites: z.boolean().optional(),
+  host: z.string().optional(),
+  port: z.number().int().min(1).max(65535).optional(),
+  tls: z.boolean().optional(),
+  nick: z.string().optional(),
+  username: z.string().optional(),
+  realname: z.string().optional(),
+  password: SecretInputSchema.optional().register(sensitive),
+  passwordFile: z.string().optional(),
+  nickserv: IrcNickServSchema.optional(),
+  channels: z.array(z.string()).optional(),
+  dmPolicy: DmPolicySchema.optional().default("pairing"),
+  allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  defaultTo: z.string().optional(),
+  groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  contextVisibility: ContextVisibilityModeSchema.optional(),
+  groups: z.record(z.string(), IrcGroupSchema.optional()).optional(),
+  mentionPatterns: z.array(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(),
+  heartbeat: ChannelHeartbeatVisibilitySchema,
+  healthMonitor: ChannelHealthMonitorSchema,
+  responsePrefix: z.string().optional()
+}).strict();
+function refineIrcAllowFromAndNickserv(value, ctx) {
+  requireOpenAllowFrom({
+    policy: value.dmPolicy,
+    allowFrom: value.allowFrom,
+    ctx,
+    path: ["allowFrom"],
+    message: 'channels.irc.dmPolicy="open" requires channels.irc.allowFrom to include "*"'
+  });
+  requireAllowlistAllowFrom({
+    policy: value.dmPolicy,
+    allowFrom: value.allowFrom,
+    ctx,
+    path: ["allowFrom"],
+    message: 'channels.irc.dmPolicy="allowlist" requires channels.irc.allowFrom to contain at least one sender ID'
+  });
+  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"
+  });
+}
+const IrcAccountSchema = IrcAccountSchemaBase.superRefine((value, ctx) => {
+  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"
+  });
+});
+IrcAccountSchemaBase.extend({
+  accounts: z.record(z.string(), IrcAccountSchema.optional()).optional(),
+  defaultAccount: z.string().optional()
+}).superRefine((value, ctx) => {
+  refineIrcAllowFromAndNickserv(value, ctx);
+  if (!value.accounts) return;
+  for (const [accountId, account] of Object.entries(value.accounts)) {
+    if (!account) continue;
+    const effectivePolicy = account.dmPolicy ?? value.dmPolicy;
+    const effectiveAllowFrom = account.allowFrom ?? value.allowFrom;
+    requireOpenAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.irc.accounts.*.dmPolicy="open" requires channels.irc.accounts.*.allowFrom (or channels.irc.allowFrom) to include "*"'
+    });
+    requireAllowlistAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.irc.accounts.*.dmPolicy="allowlist" requires channels.irc.accounts.*.allowFrom (or channels.irc.allowFrom) to contain at least one sender ID'
+    });
+  }
+});
+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().refine(isSafeScpRemoteHost, "expected SSH host or user@host (no spaces/options)").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(),
+  defaultTo: z.string().optional(),
+  groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  contextVisibility: ContextVisibilityModeSchema.optional(),
+  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(),
+  attachmentRoots: z.array(z.string().refine(isValidInboundPathRootPattern, "expected absolute path root")).optional(),
+  remoteAttachmentRoots: z.array(z.string().refine(isValidInboundPathRootPattern, "expected absolute path root")).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,
+  healthMonitor: ChannelHealthMonitorSchema,
+  responsePrefix: z.string().optional()
+}).strict();
+const IMessageAccountSchema = IMessageAccountSchemaBase;
+IMessageAccountSchemaBase.extend({
+  accounts: z.record(z.string(), IMessageAccountSchema.optional()).optional(),
+  defaultAccount: z.string().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 "*"'
+  });
+  requireAllowlistAllowFrom({
+    policy: value.dmPolicy,
+    allowFrom: value.allowFrom,
+    ctx,
+    path: ["allowFrom"],
+    message: 'channels.imessage.dmPolicy="allowlist" requires channels.imessage.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;
+    const effectiveAllowFrom = account.allowFrom ?? value.allowFrom;
+    requireOpenAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.imessage.accounts.*.dmPolicy="open" requires channels.imessage.accounts.*.allowFrom (or channels.imessage.allowFrom) to include "*"'
+    });
+    requireAllowlistAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.imessage.accounts.*.dmPolicy="allowlist" requires channels.imessage.accounts.*.allowFrom (or channels.imessage.allowFrom) to contain at least one sender ID'
+    });
+  }
+});
+const BlueBubblesAllowFromEntry = z.union([z.string(), z.number()]);
+const BlueBubblesActionSchema = z.object({
+  reactions: z.boolean().optional(),
+  edit: z.boolean().optional(),
+  unsend: z.boolean().optional(),
+  reply: z.boolean().optional(),
+  sendWithEffect: z.boolean().optional(),
+  renameGroup: z.boolean().optional(),
+  setGroupIcon: z.boolean().optional(),
+  addParticipant: z.boolean().optional(),
+  removeParticipant: z.boolean().optional(),
+  leaveGroup: z.boolean().optional(),
+  sendAttachment: z.boolean().optional()
+}).strict().optional();
+const BlueBubblesGroupConfigSchema = z.object({
+  requireMention: z.boolean().optional(),
+  tools: ToolPolicySchema,
+  toolsBySender: ToolPolicyBySenderSchema
+}).strict();
+const BlueBubblesAccountSchemaBase = z.object({
+  name: z.string().optional(),
+  capabilities: z.array(z.string()).optional(),
+  markdown: MarkdownConfigSchema,
+  configWrites: z.boolean().optional(),
+  enabled: z.boolean().optional(),
+  serverUrl: z.string().optional(),
+  password: SecretInputSchema.optional().register(sensitive),
+  webhookPath: z.string().optional(),
+  dmPolicy: DmPolicySchema.optional().default("pairing"),
+  allowFrom: z.array(BlueBubblesAllowFromEntry).optional(),
+  groupAllowFrom: z.array(BlueBubblesAllowFromEntry).optional(),
+  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  contextVisibility: ContextVisibilityModeSchema.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(),
+  mediaMaxMb: z.number().int().positive().optional(),
+  mediaLocalRoots: z.array(z.string()).optional(),
+  sendReadReceipts: z.boolean().optional(),
+  network: z.object({ dangerouslyAllowPrivateNetwork: z.boolean().optional() }).strict().optional(),
+  blockStreaming: z.boolean().optional(),
+  blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
+  groups: z.record(z.string(), BlueBubblesGroupConfigSchema.optional()).optional(),
+  enrichGroupParticipantsFromContacts: z.boolean().optional(),
+  heartbeat: ChannelHeartbeatVisibilitySchema,
+  healthMonitor: ChannelHealthMonitorSchema,
+  responsePrefix: z.string().optional()
+}).strict();
+const BlueBubblesAccountSchema = BlueBubblesAccountSchemaBase;
+BlueBubblesAccountSchemaBase.extend({
+  accounts: z.record(z.string(), BlueBubblesAccountSchema.optional()).optional(),
+  defaultAccount: z.string().optional(),
+  actions: BlueBubblesActionSchema
+}).superRefine((value, ctx) => {
+  requireOpenAllowFrom({
+    policy: value.dmPolicy,
+    allowFrom: value.allowFrom,
+    ctx,
+    path: ["allowFrom"],
+    message: 'channels.bluebubbles.dmPolicy="open" requires channels.bluebubbles.allowFrom to include "*"'
+  });
+  requireAllowlistAllowFrom({
+    policy: value.dmPolicy,
+    allowFrom: value.allowFrom,
+    ctx,
+    path: ["allowFrom"],
+    message: 'channels.bluebubbles.dmPolicy="allowlist" requires channels.bluebubbles.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;
+    const effectiveAllowFrom = account.allowFrom ?? value.allowFrom;
+    requireOpenAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.bluebubbles.accounts.*.dmPolicy="open" requires channels.bluebubbles.accounts.*.allowFrom (or channels.bluebubbles.allowFrom) to include "*"'
+    });
+    requireAllowlistAllowFrom({
+      policy: effectivePolicy,
+      allowFrom: effectiveAllowFrom,
+      ctx,
+      path: [
+        "accounts",
+        accountId,
+        "allowFrom"
+      ],
+      message: 'channels.bluebubbles.accounts.*.dmPolicy="allowlist" requires channels.bluebubbles.accounts.*.allowFrom (or channels.bluebubbles.allowFrom) to contain at least one sender ID'
+    });
+  }
+});
+const MSTeamsChannelSchema = z.object({
+  requireMention: z.boolean().optional(),
+  tools: ToolPolicySchema,
+  toolsBySender: ToolPolicyBySenderSchema,
+  replyStyle: MSTeamsReplyStyleSchema.optional()
+}).strict();
+const MSTeamsTeamSchema = z.object({
+  requireMention: z.boolean().optional(),
+  tools: ToolPolicySchema,
+  toolsBySender: ToolPolicyBySenderSchema,
+  replyStyle: MSTeamsReplyStyleSchema.optional(),
+  channels: z.record(z.string(), MSTeamsChannelSchema.optional()).optional()
+}).strict();
+z.object({
+  enabled: z.boolean().optional(),
+  capabilities: z.array(z.string()).optional(),
+  dangerouslyAllowNameMatching: z.boolean().optional(),
+  markdown: MarkdownConfigSchema,
+  configWrites: z.boolean().optional(),
+  appId: z.string().optional(),
+  appPassword: SecretInputSchema.optional().register(sensitive),
+  tenantId: z.string().optional(),
+  authType: z.enum(["secret", "federated"]).optional(),
+  certificatePath: z.string().optional(),
+  certificateThumbprint: z.string().optional(),
+  useManagedIdentity: z.boolean().optional(),
+  managedIdentityClientId: 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(),
+  defaultTo: z.string().optional(),
+  groupAllowFrom: z.array(z.string()).optional(),
+  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  contextVisibility: ContextVisibilityModeSchema.optional(),
+  textChunkLimit: z.number().int().positive().optional(),
+  chunkMode: z.enum(["length", "newline"]).optional(),
+  typingIndicator: z.boolean().optional(),
+  blockStreaming: z.boolean().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(),
+  mediaMaxMb: z.number().positive().optional(),
+  sharePointSiteId: z.string().optional(),
+  heartbeat: ChannelHeartbeatVisibilitySchema,
+  healthMonitor: ChannelHealthMonitorSchema,
+  responsePrefix: z.string().optional(),
+  welcomeCard: z.boolean().optional(),
+  promptStarters: z.array(z.string()).optional(),
+  groupWelcomeCard: z.boolean().optional(),
+  feedbackEnabled: z.boolean().optional(),
+  feedbackReflection: z.boolean().optional(),
+  feedbackReflectionCooldownMs: z.number().int().min(0).optional(),
+  delegatedAuth: z.object({
+    enabled: z.boolean().optional(),
+    scopes: z.array(z.string()).optional()
+  }).strict().optional(),
+  sso: z.object({
+    enabled: z.boolean().optional(),
+    connectionName: z.string().optional()
+  }).strict().optional()
+}).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 "*"'
+  });
+  requireAllowlistAllowFrom({
+    policy: value.dmPolicy,
+    allowFrom: value.allowFrom,
+    ctx,
+    path: ["allowFrom"],
+    message: 'channels.msteams.dmPolicy="allowlist" requires channels.msteams.allowFrom to contain at least one sender ID'
+  });
+  if (value.sso?.enabled === true && !value.sso.connectionName?.trim()) ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    path: ["sso", "connectionName"],
+    message: "channels.msteams.sso.enabled=true requires channels.msteams.sso.connectionName to identify the Bot Framework OAuth connection"
+  });
+});
+export {
+  ChannelHealthMonitorSchema as c,
+  ChannelHeartbeatVisibilitySchema as l
+};