@workclaw/openclaw-workclaw 1.0.202 → 1.0.331

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

@@ -0,0 +1,597 @@
+import { s as isValidFileSecretRefId, o as isValidExecSecretRefId, a as formatExecSecretRefIdValidationMessage } from "./ref-contract-B1q5N0Lz.js";
+import { s as normalizeStringEntries } from "./string-normalization-DIJRAo0o.js";
+import { t as isSafeExecutableValue } from "./exec-safety-C8v0dsfc.js";
+import { t as sensitive } from "./zod-schema.sensitive-BFZ4qze6.js";
+import path from "node:path";
+import { z } from "zod";
+const MODEL_APIS = [
+  "openai-completions",
+  "openai-responses",
+  "openai-codex-responses",
+  "anthropic-messages",
+  "google-generative-ai",
+  "github-copilot",
+  "bedrock-converse-stream",
+  "ollama",
+  "azure-openai-responses"
+];
+const AllowDenyActionSchema = z.union([z.literal("allow"), z.literal("deny")]);
+const AllowDenyChatTypeSchema = z.union([
+  z.literal("direct"),
+  z.literal("group"),
+  z.literal("channel"),
+  z.literal("dm")
+]).optional();
+function createAllowDenyChannelRulesSchema() {
+  return z.object({
+    default: AllowDenyActionSchema.optional(),
+    rules: z.array(z.object({
+      action: AllowDenyActionSchema,
+      match: z.object({
+        channel: z.string().optional(),
+        chatType: AllowDenyChatTypeSchema,
+        keyPrefix: z.string().optional(),
+        rawKeyPrefix: z.string().optional()
+      }).strict().optional()
+    }).strict()).optional()
+  }).strict().optional();
+}
+const ENV_SECRET_REF_ID_PATTERN = /^[A-Z][A-Z0-9_]{0,127}$/;
+const SECRET_PROVIDER_ALIAS_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
+const WINDOWS_ABS_PATH_PATTERN = /^[A-Za-z]:[\\/]/;
+const WINDOWS_UNC_PATH_PATTERN = /^\\\\[^\\]+\\[^\\]+/;
+function isAbsolutePath(value) {
+  return path.isAbsolute(value) || WINDOWS_ABS_PATH_PATTERN.test(value) || WINDOWS_UNC_PATH_PATTERN.test(value);
+}
+const EnvSecretRefSchema = z.object({
+  source: z.literal("env"),
+  provider: z.string().regex(SECRET_PROVIDER_ALIAS_PATTERN, 'Secret reference provider must match /^[a-z][a-z0-9_-]{0,63}$/ (example: "default").'),
+  id: z.string().regex(ENV_SECRET_REF_ID_PATTERN, 'Env secret reference id must match /^[A-Z][A-Z0-9_]{0,127}$/ (example: "OPENAI_API_KEY").')
+}).strict();
+const FileSecretRefSchema = z.object({
+  source: z.literal("file"),
+  provider: z.string().regex(SECRET_PROVIDER_ALIAS_PATTERN, 'Secret reference provider must match /^[a-z][a-z0-9_-]{0,63}$/ (example: "default").'),
+  id: z.string().refine(isValidFileSecretRefId, 'File secret reference id must be an absolute JSON pointer (example: "/providers/openai/apiKey"), or "value" for singleValue mode.')
+}).strict();
+const ExecSecretRefSchema = z.object({
+  source: z.literal("exec"),
+  provider: z.string().regex(SECRET_PROVIDER_ALIAS_PATTERN, 'Secret reference provider must match /^[a-z][a-z0-9_-]{0,63}$/ (example: "default").'),
+  id: z.string().refine(isValidExecSecretRefId, formatExecSecretRefIdValidationMessage())
+}).strict();
+const SecretRefSchema = z.discriminatedUnion("source", [
+  EnvSecretRefSchema,
+  FileSecretRefSchema,
+  ExecSecretRefSchema
+]);
+const SecretInputSchema = z.union([z.string(), SecretRefSchema]);
+const SecretsEnvProviderSchema = z.object({
+  source: z.literal("env"),
+  allowlist: z.array(z.string().regex(ENV_SECRET_REF_ID_PATTERN)).max(256).optional()
+}).strict();
+const SecretsFileProviderSchema = z.object({
+  source: z.literal("file"),
+  path: z.string().min(1),
+  mode: z.union([z.literal("singleValue"), z.literal("json")]).optional(),
+  timeoutMs: z.number().int().positive().max(12e4).optional(),
+  maxBytes: z.number().int().positive().max(20 * 1024 * 1024).optional()
+}).strict();
+const SecretsExecProviderSchema = z.object({
+  source: z.literal("exec"),
+  command: z.string().min(1).refine((value) => isSafeExecutableValue(value), "secrets.providers.*.command is unsafe.").refine((value) => isAbsolutePath(value), "secrets.providers.*.command must be an absolute path."),
+  args: z.array(z.string().max(1024)).max(128).optional(),
+  timeoutMs: z.number().int().positive().max(12e4).optional(),
+  noOutputTimeoutMs: z.number().int().positive().max(12e4).optional(),
+  maxOutputBytes: z.number().int().positive().max(20 * 1024 * 1024).optional(),
+  jsonOnly: z.boolean().optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  passEnv: z.array(z.string().regex(ENV_SECRET_REF_ID_PATTERN)).max(128).optional(),
+  trustedDirs: z.array(z.string().min(1).refine((value) => isAbsolutePath(value), "trustedDirs entries must be absolute paths.")).max(64).optional(),
+  allowInsecurePath: z.boolean().optional(),
+  allowSymlinkCommand: z.boolean().optional()
+}).strict();
+const SecretProviderSchema = z.discriminatedUnion("source", [
+  SecretsEnvProviderSchema,
+  SecretsFileProviderSchema,
+  SecretsExecProviderSchema
+]);
+const SecretsConfigSchema = z.object({
+  providers: z.object({}).catchall(SecretProviderSchema).optional(),
+  defaults: z.object({
+    env: z.string().regex(SECRET_PROVIDER_ALIAS_PATTERN).optional(),
+    file: z.string().regex(SECRET_PROVIDER_ALIAS_PATTERN).optional(),
+    exec: z.string().regex(SECRET_PROVIDER_ALIAS_PATTERN).optional()
+  }).strict().optional(),
+  resolution: z.object({
+    maxProviderConcurrency: z.number().int().positive().max(16).optional(),
+    maxRefsPerProvider: z.number().int().positive().max(4096).optional(),
+    maxBatchBytes: z.number().int().positive().max(5 * 1024 * 1024).optional()
+  }).strict().optional()
+}).strict().optional();
+const ModelApiSchema = z.enum(MODEL_APIS);
+const ModelCompatSchema = z.object({
+  supportsStore: z.boolean().optional(),
+  supportsDeveloperRole: z.boolean().optional(),
+  supportsReasoningEffort: z.boolean().optional(),
+  supportsUsageInStreaming: z.boolean().optional(),
+  supportsTools: z.boolean().optional(),
+  supportsStrictMode: z.boolean().optional(),
+  requiresStringContent: z.boolean().optional(),
+  maxTokensField: z.union([z.literal("max_completion_tokens"), z.literal("max_tokens")]).optional(),
+  thinkingFormat: z.union([
+    z.literal("openai"),
+    z.literal("openrouter"),
+    z.literal("zai"),
+    z.literal("qwen"),
+    z.literal("qwen-chat-template")
+  ]).optional(),
+  requiresToolResultName: z.boolean().optional(),
+  requiresAssistantAfterToolResult: z.boolean().optional(),
+  requiresThinkingAsText: z.boolean().optional(),
+  toolSchemaProfile: z.string().optional(),
+  unsupportedToolSchemaKeywords: z.array(z.string().min(1)).optional(),
+  nativeWebSearchTool: z.boolean().optional(),
+  toolCallArgumentsEncoding: z.string().optional(),
+  requiresMistralToolIds: z.boolean().optional(),
+  requiresOpenAiAnthropicToolPayload: z.boolean().optional()
+}).strict().optional();
+const ConfiguredProviderRequestTlsSchema = z.object({
+  ca: SecretInputSchema.optional().register(sensitive),
+  cert: SecretInputSchema.optional().register(sensitive),
+  key: SecretInputSchema.optional().register(sensitive),
+  passphrase: SecretInputSchema.optional().register(sensitive),
+  serverName: z.string().optional(),
+  insecureSkipVerify: z.boolean().optional()
+}).strict().optional();
+const ConfiguredProviderRequestAuthSchema = z.union([
+  z.object({ mode: z.literal("provider-default") }).strict(),
+  z.object({
+    mode: z.literal("authorization-bearer"),
+    token: SecretInputSchema.register(sensitive)
+  }).strict(),
+  z.object({
+    mode: z.literal("header"),
+    headerName: z.string().min(1),
+    value: SecretInputSchema.register(sensitive),
+    prefix: z.string().optional()
+  }).strict()
+]).optional();
+const ConfiguredProviderRequestProxySchema = z.union([z.object({
+  mode: z.literal("env-proxy"),
+  tls: ConfiguredProviderRequestTlsSchema
+}).strict(), z.object({
+  mode: z.literal("explicit-proxy"),
+  url: z.string().min(1),
+  tls: ConfiguredProviderRequestTlsSchema
+}).strict()]).optional();
+const ConfiguredProviderRequestFields = {
+  headers: z.record(z.string(), SecretInputSchema.register(sensitive)).optional(),
+  auth: ConfiguredProviderRequestAuthSchema,
+  proxy: ConfiguredProviderRequestProxySchema,
+  tls: ConfiguredProviderRequestTlsSchema
+};
+const ConfiguredProviderRequestSchema = z.object(ConfiguredProviderRequestFields).strict().optional();
+const ConfiguredModelProviderRequestSchema = z.object({
+  ...ConfiguredProviderRequestFields,
+  allowPrivateNetwork: z.boolean().optional()
+}).strict().optional();
+const ModelDefinitionSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  api: ModelApiSchema.optional(),
+  reasoning: z.boolean().optional(),
+  input: z.array(z.union([z.literal("text"), z.literal("image")])).optional(),
+  cost: z.object({
+    input: z.number().optional(),
+    output: z.number().optional(),
+    cacheRead: z.number().optional(),
+    cacheWrite: z.number().optional()
+  }).strict().optional(),
+  contextWindow: z.number().positive().optional(),
+  contextTokens: z.number().int().positive().optional(),
+  maxTokens: z.number().positive().optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  compat: ModelCompatSchema
+}).strict();
+const ModelProviderSchema = z.object({
+  baseUrl: z.string().min(1),
+  apiKey: SecretInputSchema.optional().register(sensitive),
+  auth: z.union([
+    z.literal("api-key"),
+    z.literal("aws-sdk"),
+    z.literal("oauth"),
+    z.literal("token")
+  ]).optional(),
+  api: ModelApiSchema.optional(),
+  injectNumCtxForOpenAICompat: z.boolean().optional(),
+  headers: z.record(z.string(), SecretInputSchema.register(sensitive)).optional(),
+  authHeader: z.boolean().optional(),
+  request: ConfiguredModelProviderRequestSchema,
+  models: z.array(ModelDefinitionSchema)
+}).strict();
+z.object({
+  enabled: z.boolean().optional(),
+  region: z.string().optional(),
+  providerFilter: z.array(z.string()).optional(),
+  refreshInterval: z.number().int().nonnegative().optional(),
+  defaultContextWindow: z.number().int().positive().optional(),
+  defaultMaxTokens: z.number().int().positive().optional()
+}).strict().optional();
+const ModelsConfigSchema = z.object({
+  mode: z.union([z.literal("merge"), z.literal("replace")]).optional(),
+  providers: z.record(z.string(), ModelProviderSchema).optional()
+}).strict().optional();
+const GroupChatSchema = z.object({
+  mentionPatterns: z.array(z.string()).optional(),
+  historyLimit: z.number().int().positive().optional()
+}).strict().optional();
+const DmConfigSchema = z.object({ historyLimit: z.number().int().min(0).optional() }).strict();
+const IdentitySchema = z.object({
+  name: z.string().optional(),
+  theme: z.string().optional(),
+  emoji: z.string().optional(),
+  avatar: z.string().optional()
+}).strict().optional();
+const QueueModeSchema = z.union([
+  z.literal("steer"),
+  z.literal("followup"),
+  z.literal("collect"),
+  z.literal("steer-backlog"),
+  z.literal("steer+backlog"),
+  z.literal("queue"),
+  z.literal("interrupt")
+]);
+const QueueDropSchema = z.union([
+  z.literal("old"),
+  z.literal("new"),
+  z.literal("summarize")
+]);
+const ReplyToModeSchema = z.union([
+  z.literal("off"),
+  z.literal("first"),
+  z.literal("all"),
+  z.literal("batched")
+]);
+const TypingModeSchema = z.union([
+  z.literal("never"),
+  z.literal("instant"),
+  z.literal("thinking"),
+  z.literal("message")
+]);
+const GroupPolicySchema = z.enum([
+  "open",
+  "disabled",
+  "allowlist"
+]);
+const DmPolicySchema = z.enum([
+  "pairing",
+  "allowlist",
+  "open",
+  "disabled"
+]);
+const ContextVisibilityModeSchema = z.enum([
+  "all",
+  "allowlist",
+  "allowlist_quote"
+]);
+const BlockStreamingCoalesceSchema = z.object({
+  minChars: z.number().int().positive().optional(),
+  maxChars: z.number().int().positive().optional(),
+  idleMs: z.number().int().nonnegative().optional()
+}).strict();
+({
+  historyLimit: z.number().int().min(0).optional(),
+  dmHistoryLimit: z.number().int().min(0).optional(),
+  contextVisibility: ContextVisibilityModeSchema.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(),
+  responsePrefix: z.string().optional(),
+  mediaMaxMb: z.number().positive().optional()
+});
+const BlockStreamingChunkSchema = z.object({
+  minChars: z.number().int().positive().optional(),
+  maxChars: z.number().int().positive().optional(),
+  breakPreference: z.union([
+    z.literal("paragraph"),
+    z.literal("newline"),
+    z.literal("sentence")
+  ]).optional()
+}).strict();
+const MarkdownTableModeSchema = z.enum([
+  "off",
+  "bullets",
+  "code",
+  "block"
+]);
+const MarkdownConfigSchema = z.object({ tables: MarkdownTableModeSchema.optional() }).strict().optional();
+const TtsProviderSchema = z.string().min(1);
+const TtsModeSchema = z.enum(["final", "all"]);
+const TtsAutoSchema = z.enum([
+  "off",
+  "always",
+  "inbound",
+  "tagged"
+]);
+const TtsProviderConfigSchema = z.object({ apiKey: SecretInputSchema.optional().register(sensitive) }).catchall(z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null(),
+  z.array(z.unknown()),
+  z.record(z.string(), z.unknown())
+]));
+const TtsConfigSchema = z.object({
+  auto: TtsAutoSchema.optional(),
+  enabled: z.boolean().optional(),
+  mode: TtsModeSchema.optional(),
+  provider: TtsProviderSchema.optional(),
+  summaryModel: z.string().optional(),
+  modelOverrides: z.object({
+    enabled: z.boolean().optional(),
+    allowText: z.boolean().optional(),
+    allowProvider: z.boolean().optional(),
+    allowVoice: z.boolean().optional(),
+    allowModelId: z.boolean().optional(),
+    allowVoiceSettings: z.boolean().optional(),
+    allowNormalization: z.boolean().optional(),
+    allowSeed: z.boolean().optional()
+  }).strict().optional(),
+  providers: z.record(z.string(), TtsProviderConfigSchema).optional(),
+  prefsPath: z.string().optional(),
+  maxTextLength: z.number().int().min(1).optional(),
+  timeoutMs: z.number().int().min(1e3).max(12e4).optional()
+}).strict().optional();
+const HumanDelaySchema = z.object({
+  mode: z.union([
+    z.literal("off"),
+    z.literal("natural"),
+    z.literal("custom")
+  ]).optional(),
+  minMs: z.number().int().nonnegative().optional(),
+  maxMs: z.number().int().nonnegative().optional()
+}).strict();
+const CliBackendWatchdogModeSchema = z.object({
+  noOutputTimeoutMs: z.number().int().min(1e3).optional(),
+  noOutputTimeoutRatio: z.number().min(0.05).max(0.95).optional(),
+  minMs: z.number().int().min(1e3).optional(),
+  maxMs: z.number().int().min(1e3).optional()
+}).strict().optional();
+const CliBackendSchema = z.object({
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  output: z.union([
+    z.literal("json"),
+    z.literal("text"),
+    z.literal("jsonl")
+  ]).optional(),
+  resumeOutput: z.union([
+    z.literal("json"),
+    z.literal("text"),
+    z.literal("jsonl")
+  ]).optional(),
+  jsonlDialect: z.literal("claude-stream-json").optional(),
+  input: z.union([z.literal("arg"), z.literal("stdin")]).optional(),
+  maxPromptArgChars: z.number().int().positive().optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  clearEnv: z.array(z.string()).optional(),
+  modelArg: z.string().optional(),
+  modelAliases: z.record(z.string(), z.string()).optional(),
+  sessionArg: z.string().optional(),
+  sessionArgs: z.array(z.string()).optional(),
+  resumeArgs: z.array(z.string()).optional(),
+  sessionMode: z.union([
+    z.literal("always"),
+    z.literal("existing"),
+    z.literal("none")
+  ]).optional(),
+  sessionIdFields: z.array(z.string()).optional(),
+  systemPromptArg: z.string().optional(),
+  systemPromptFileConfigArg: z.string().optional(),
+  systemPromptFileConfigKey: z.string().optional(),
+  systemPromptMode: z.union([z.literal("append"), z.literal("replace")]).optional(),
+  systemPromptWhen: z.union([
+    z.literal("first"),
+    z.literal("always"),
+    z.literal("never")
+  ]).optional(),
+  imageArg: z.string().optional(),
+  imageMode: z.union([z.literal("repeat"), z.literal("list")]).optional(),
+  imagePathScope: z.union([z.literal("temp"), z.literal("workspace")]).optional(),
+  serialize: z.boolean().optional(),
+  reliability: z.object({ watchdog: z.object({
+    fresh: CliBackendWatchdogModeSchema,
+    resume: CliBackendWatchdogModeSchema
+  }).strict().optional() }).strict().optional()
+}).strict();
+const normalizeAllowFrom = (values) => normalizeStringEntries(values);
+const requireOpenAllowFrom = (params) => {
+  if (params.policy !== "open") return;
+  if (normalizeAllowFrom(params.allowFrom).includes("*")) return;
+  params.ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    path: params.path,
+    message: params.message
+  });
+};
+const requireAllowlistAllowFrom = (params) => {
+  if (params.policy !== "allowlist") return;
+  if (normalizeAllowFrom(params.allowFrom).length > 0) return;
+  params.ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    path: params.path,
+    message: params.message
+  });
+};
+const MSTeamsReplyStyleSchema = z.enum(["thread", "top-level"]);
+const RetryConfigSchema = z.object({
+  attempts: z.number().int().min(1).optional(),
+  minDelayMs: z.number().int().min(0).optional(),
+  maxDelayMs: z.number().int().min(0).optional(),
+  jitter: z.number().min(0).max(1).optional()
+}).strict().optional();
+const QueueModeBySurfaceSchema = z.object({
+  whatsapp: QueueModeSchema.optional(),
+  telegram: QueueModeSchema.optional(),
+  discord: QueueModeSchema.optional(),
+  irc: QueueModeSchema.optional(),
+  slack: QueueModeSchema.optional(),
+  mattermost: QueueModeSchema.optional(),
+  signal: QueueModeSchema.optional(),
+  imessage: QueueModeSchema.optional(),
+  msteams: QueueModeSchema.optional(),
+  webchat: QueueModeSchema.optional()
+}).strict().optional();
+const DebounceMsBySurfaceSchema = z.record(z.string(), z.number().int().nonnegative()).optional();
+const QueueSchema = z.object({
+  mode: QueueModeSchema.optional(),
+  byChannel: QueueModeBySurfaceSchema,
+  debounceMs: z.number().int().nonnegative().optional(),
+  debounceMsByChannel: DebounceMsBySurfaceSchema,
+  cap: z.number().int().positive().optional(),
+  drop: QueueDropSchema.optional()
+}).strict().optional();
+const InboundDebounceSchema = z.object({
+  debounceMs: z.number().int().nonnegative().optional(),
+  byChannel: DebounceMsBySurfaceSchema
+}).strict().optional();
+const TranscribeAudioSchema = z.object({
+  command: z.array(z.string()).superRefine((value, ctx) => {
+    const executable = value[0];
+    if (!isSafeExecutableValue(executable)) ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: [0],
+      message: "expected safe executable name or path"
+    });
+  }),
+  timeoutSeconds: z.number().int().positive().optional()
+}).strict().optional();
+const HexColorSchema = z.string().regex(/^#?[0-9a-fA-F]{6}$/, "expected hex color (RRGGBB)");
+const ExecutableTokenSchema = z.string().refine(isSafeExecutableValue, "expected safe executable name or path");
+const MediaUnderstandingScopeSchema = createAllowDenyChannelRulesSchema();
+const MediaUnderstandingCapabilitiesSchema = z.array(z.union([
+  z.literal("image"),
+  z.literal("audio"),
+  z.literal("video")
+])).optional();
+const MediaUnderstandingAttachmentsSchema = z.object({
+  mode: z.union([z.literal("first"), z.literal("all")]).optional(),
+  maxAttachments: z.number().int().positive().optional(),
+  prefer: z.union([
+    z.literal("first"),
+    z.literal("last"),
+    z.literal("path"),
+    z.literal("url")
+  ]).optional()
+}).strict().optional();
+const DeepgramAudioSchema = z.object({
+  detectLanguage: z.boolean().optional(),
+  punctuate: z.boolean().optional(),
+  smartFormat: z.boolean().optional()
+}).strict().optional();
+const ProviderOptionValueSchema = z.union([
+  z.string(),
+  z.number(),
+  z.boolean()
+]);
+const ProviderOptionsSchema = z.record(z.string(), z.record(z.string(), ProviderOptionValueSchema)).optional();
+const MediaUnderstandingRuntimeFields = {
+  prompt: z.string().optional(),
+  timeoutSeconds: z.number().int().positive().optional(),
+  language: z.string().optional(),
+  providerOptions: ProviderOptionsSchema,
+  deepgram: DeepgramAudioSchema,
+  baseUrl: z.string().optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  request: ConfiguredProviderRequestSchema
+};
+const MediaUnderstandingModelSchema = z.object({
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  capabilities: MediaUnderstandingCapabilitiesSchema,
+  type: z.union([z.literal("provider"), z.literal("cli")]).optional(),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  maxChars: z.number().int().positive().optional(),
+  maxBytes: z.number().int().positive().optional(),
+  ...MediaUnderstandingRuntimeFields,
+  profile: z.string().optional(),
+  preferredProfile: z.string().optional()
+}).strict().optional();
+const ToolsMediaUnderstandingSchema = z.object({
+  enabled: z.boolean().optional(),
+  scope: MediaUnderstandingScopeSchema,
+  maxBytes: z.number().int().positive().optional(),
+  maxChars: z.number().int().positive().optional(),
+  ...MediaUnderstandingRuntimeFields,
+  attachments: MediaUnderstandingAttachmentsSchema,
+  models: z.array(MediaUnderstandingModelSchema).optional(),
+  echoTranscript: z.boolean().optional(),
+  echoFormat: z.string().optional()
+}).strict().optional();
+const ToolsMediaSchema = z.object({
+  models: z.array(MediaUnderstandingModelSchema).optional(),
+  concurrency: z.number().int().positive().optional(),
+  asyncCompletion: z.object({ directSend: z.boolean().optional() }).strict().optional(),
+  image: ToolsMediaUnderstandingSchema.optional(),
+  audio: ToolsMediaUnderstandingSchema.optional(),
+  video: ToolsMediaUnderstandingSchema.optional()
+}).strict().optional();
+const LinkModelSchema = z.object({
+  type: z.literal("cli").optional(),
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
+  timeoutSeconds: z.number().int().positive().optional()
+}).strict();
+const ToolsLinksSchema = z.object({
+  enabled: z.boolean().optional(),
+  scope: MediaUnderstandingScopeSchema,
+  maxLinks: z.number().int().positive().optional(),
+  timeoutSeconds: z.number().int().positive().optional(),
+  models: z.array(LinkModelSchema).optional()
+}).strict().optional();
+const NativeCommandsSettingSchema = z.union([z.boolean(), z.literal("auto")]);
+const ProviderCommandsSchema = z.object({
+  native: NativeCommandsSettingSchema.optional(),
+  nativeSkills: NativeCommandsSettingSchema.optional()
+}).strict().optional();
+export {
+  TtsAutoSchema as A,
+  SecretInputSchema as C,
+  ToolsLinksSchema as D,
+  SecretsConfigSchema as E,
+  requireAllowlistAllowFrom as F,
+  requireOpenAllowFrom as I,
+  createAllowDenyChannelRulesSchema as L,
+  TtsModeSchema as M,
+  TtsProviderSchema as N,
+  ToolsMediaSchema as O,
+  TypingModeSchema as P,
+  MODEL_APIS as R,
+  RetryConfigSchema as S,
+  SecretRefSchema as T,
+  NativeCommandsSettingSchema as _,
+  DmConfigSchema as a,
+  GroupChatSchema as c,
+  HumanDelaySchema as d,
+  IdentitySchema as f,
+  ModelsConfigSchema as g,
+  MarkdownConfigSchema as h,
+  ContextVisibilityModeSchema as i,
+  TtsConfigSchema as j,
+  TranscribeAudioSchema as k,
+  GroupPolicySchema as l,
+  MSTeamsReplyStyleSchema as m,
+  BlockStreamingCoalesceSchema as n,
+  DmPolicySchema as o,
+  InboundDebounceSchema as p,
+  CliBackendSchema as r,
+  ExecutableTokenSchema as s,
+  BlockStreamingChunkSchema as t,
+  HexColorSchema as u,
+  ProviderCommandsSchema as v,
+  SecretProviderSchema as w,
+  ReplyToModeSchema as x,
+  QueueSchema as y
+};