// This file is auto-generated by @hey-api/openapi-ts

import * as z from 'zod'

/**
 * AgentApiAccessResponse
 */
export const zAgentApiAccessResponse = z.object({
  api_key_count: z.int(),
  api_rph: z.int(),
  api_rpm: z.int(),
  chat_endpoint: z.string(),
  conversations_endpoint: z.string(),
  enabled: z.boolean(),
  files_upload_endpoint: z.string(),
  info_endpoint: z.string(),
  messages_endpoint: z.string(),
  meta_endpoint: z.string(),
  parameters_endpoint: z.string(),
  service_api_base_url: z.string(),
  stop_endpoint: z.string(),
  streaming_only: z.boolean().optional().default(true),
})

/**
 * AgentApiStatusPayload
 */
export const zAgentApiStatusPayload = z.object({
  enable_api: z.boolean(),
})

/**
 * ApiKeyItem
 */
export const zApiKeyItem = z.object({
  created_at: z.int().nullish(),
  id: z.string(),
  last_used_at: z.int().nullish(),
  token: z.string(),
  type: z.string(),
})

/**
 * ApiKeyList
 */
export const zApiKeyList = z.object({
  data: z.array(zApiKeyItem),
})

/**
 * AudioTranscriptResponse
 */
export const zAudioTranscriptResponse = z.object({
  text: z.string(),
})

/**
 * SimpleResultResponse
 */
export const zSimpleResultResponse = z.object({
  result: z.string(),
})

/**
 * AgentSimpleResultResponse
 */
export const zAgentSimpleResultResponse = z.object({
  result: z.string(),
})

/**
 * AgentBuildDraftApplyResponse
 */
export const zAgentBuildDraftApplyResponse = z.object({
  draft: z.record(z.string(), z.unknown()),
  result: z.string(),
})

/**
 * AgentBuildDraftCheckoutPayload
 */
export const zAgentBuildDraftCheckoutPayload = z.object({
  force: z.boolean().optional().default(false),
})

/**
 * SuggestedQuestionsResponse
 */
export const zSuggestedQuestionsResponse = z.object({
  data: z.array(z.string()),
})

/**
 * AgentConfigFileUploadPayload
 */
export const zAgentConfigFileUploadPayload = z.object({
  upload_file_id: z.string(),
})

/**
 * AgentConfigDeleteResponse
 */
export const zAgentConfigDeleteResponse = z.object({
  removed_names: z.array(z.string()).optional(),
  result: z.literal('success'),
})

/**
 * AgentConfigDownloadResponse
 */
export const zAgentConfigDownloadResponse = z.object({
  url: z.string(),
})

/**
 * AgentConfigFilePreviewResponse
 */
export const zAgentConfigFilePreviewResponse = z.object({
  binary: z.boolean(),
  name: z.string(),
  size: z.int().nullish(),
  text: z.string().nullish(),
  truncated: z.boolean(),
})

/**
 * AgentConfigSkillFilePreviewResponse
 */
export const zAgentConfigSkillFilePreviewResponse = z.object({
  binary: z.boolean(),
  path: z.string(),
  size: z.int().nullish(),
  text: z.string().nullish(),
  truncated: z.boolean(),
})

/**
 * AgentDebugConversationRefreshResponse
 */
export const zAgentDebugConversationRefreshResponse = z.object({
  debug_conversation_has_messages: z.boolean().optional().default(false),
  debug_conversation_id: z.string(),
  debug_conversation_message_count: z.int().optional().default(0),
})

/**
 * AgentDriveDownloadResponse
 */
export const zAgentDriveDownloadResponse = z.object({
  url: z.string(),
})

/**
 * AgentDrivePreviewResponse
 */
export const zAgentDrivePreviewResponse = z.object({
  binary: z.boolean(),
  key: z.string(),
  size: z.int().nullish(),
  text: z.string().nullish(),
  truncated: z.boolean(),
})

/**
 * MessageFeedbackPayload
 */
export const zMessageFeedbackPayload = z.object({
  content: z.string().nullish(),
  message_id: z.string(),
  rating: z.enum(['dislike', 'like']).nullish(),
})

/**
 * AgentDriveDeleteResponse
 */
export const zAgentDriveDeleteResponse = z.object({
  removed_keys: z.array(z.string()).optional(),
  result: z.string(),
})

/**
 * AgentDriveFilePayload
 */
export const zAgentDriveFilePayload = z.object({
  upload_file_id: z.string(),
})

/**
 * AgentPublishPayload
 */
export const zAgentPublishPayload = z.object({
  version_note: z.string().nullish(),
})

/**
 * SandboxInfoResponse
 */
export const zSandboxInfoResponse = z.object({
  session_id: z.string(),
  workspace_cwd: z.string(),
})

/**
 * SandboxReadResponse
 */
export const zSandboxReadResponse = z.object({
  binary: z.boolean(),
  path: z.string(),
  size: z.int().nullish(),
  text: z.string().nullish(),
  truncated: z.boolean(),
})

/**
 * AgentSandboxUploadPayload
 */
export const zAgentSandboxUploadPayload = z.object({
  conversation_id: z.string().min(1),
  path: z.string().min(1),
})

/**
 * SandboxUploadResponse
 */
export const zSandboxUploadResponse = z.object({
  url: z.string(),
})

/**
 * AgentConfigSnapshotRestoreResponse
 */
export const zAgentConfigSnapshotRestoreResponse = z.object({
  active_config_snapshot_id: z.string(),
  draft_config_id: z.string().nullish(),
  restored_version_id: z.string().nullish(),
  result: z.literal('success'),
})

/**
 * IconType
 */
export const zIconType = z.enum(['emoji', 'image', 'link'])

/**
 * AgentAppCreatePayload
 */
export const zAgentAppCreatePayload = z.object({
  description: z.string().max(400).nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zIconType.nullish(),
  name: z.string().min(1),
  role: z.string().max(255).nullish(),
})

/**
 * AgentAppUpdatePayload
 */
export const zAgentAppUpdatePayload = z.object({
  description: z.string().max(400).nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zIconType.nullish(),
  max_active_requests: z.int().nullish(),
  name: z.string().min(1),
  role: z.string().max(255).nullish(),
  use_icon_as_answer_icon: z.boolean().nullish(),
})

/**
 * AgentAppCopyPayload
 */
export const zAgentAppCopyPayload = z.object({
  description: z.string().max(400).nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zIconType.nullish(),
  name: z.string().nullish(),
  role: z.string().max(255).nullish(),
})

/**
 * DeletedTool
 */
export const zDeletedTool = z.object({
  provider_id: z.string(),
  tool_name: z.string(),
  type: z.string(),
})

/**
 * AppDetailSiteResponse
 */
export const zAppDetailSiteResponse = z.object({
  access_token: z.string().nullish(),
  app_base_url: z.string().nullish(),
  chat_color_theme: z.string().nullish(),
  chat_color_theme_inverted: z.boolean().nullish(),
  code: z.string().nullish(),
  copyright: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  custom_disclaimer: z.string().nullish(),
  customize_domain: z.string().nullish(),
  customize_token_strategy: z.string().nullish(),
  default_language: z.string().nullish(),
  description: z.string().nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.union([z.string(), zIconType]).nullish(),
  icon_url: z.string().nullable(),
  input_placeholder: z.string().nullish(),
  privacy_policy: z.string().nullish(),
  prompt_public: z.boolean().nullish(),
  show_workflow_steps: z.boolean().nullish(),
  title: z.string().nullish(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
  use_icon_as_answer_icon: z.boolean().nullish(),
})

/**
 * Tag
 */
export const zTag = z.object({
  id: z.string(),
  name: z.string(),
  type: z.string(),
})

/**
 * WorkflowPartial
 */
export const zWorkflowPartial = z.object({
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  id: z.string(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
})

/**
 * ComposerBindingPayload
 */
export const zComposerBindingPayload = z.object({
  agent_id: z.string().nullish(),
  binding_type: z.enum(['inline_agent', 'roster_agent']),
  current_snapshot_id: z.string().nullish(),
})

/**
 * AgentIconType
 *
 * Supported icon storage formats for Agent roster entries.
 */
export const zAgentIconType = z.enum(['emoji', 'image', 'link'])

/**
 * ComposerSaveStrategy
 */
export const zComposerSaveStrategy = z.enum([
  'node_job_only',
  'save_as_new_agent',
  'save_as_new_version',
  'save_to_current_version',
  'save_to_roster',
])

/**
 * ComposerSoulLockPayload
 */
export const zComposerSoulLockPayload = z.object({
  locked: z.boolean().optional().default(true),
  unlocked_from_version_id: z.string().nullish(),
})

/**
 * ComposerVariant
 */
export const zComposerVariant = z.enum(['agent_app', 'workflow'])

/**
 * AgentConfigSnapshotSummaryResponse
 */
export const zAgentConfigSnapshotSummaryResponse = z.object({
  agent_id: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  display_version: z.int().nullish(),
  id: z.string(),
  snapshot_version: z.int().nullish(),
  summary: z.string().nullish(),
  version: z.int(),
  version_note: z.string().nullish(),
})

/**
 * AgentConfigSnapshotListResponse
 */
export const zAgentConfigSnapshotListResponse = z.object({
  data: z.array(zAgentConfigSnapshotSummaryResponse),
})

/**
 * ComposerCandidateCapabilities
 */
export const zComposerCandidateCapabilities = z.object({
  human_roster_available: z.boolean().optional().default(false),
})

/**
 * ComposerKnowledgePlaceholderResponse
 */
export const zComposerKnowledgePlaceholderResponse = z.object({
  id: z.string(),
  placeholder_name: z.string(),
})

/**
 * ComposerValidationWarningResponse
 */
export const zComposerValidationWarningResponse = z.object({
  code: z.string(),
  id: z.string().nullish(),
  kind: z.string().nullish(),
  message: z.string().nullish(),
  surface: z.string().nullish(),
})

/**
 * AgentComposerValidateResponse
 */
export const zAgentComposerValidateResponse = z.object({
  errors: z.array(z.string()).optional(),
  knowledge_retrieval_placeholder: z.array(zComposerKnowledgePlaceholderResponse).optional(),
  result: z.literal('success'),
  warnings: z.array(zComposerValidationWarningResponse).optional(),
})

/**
 * ComposerValidationFindingsResponse
 */
export const zComposerValidationFindingsResponse = z.object({
  knowledge_retrieval_placeholder: z.array(zComposerKnowledgePlaceholderResponse).optional(),
  warnings: z.array(zComposerValidationWarningResponse).optional(),
})

/**
 * AgentConfigVersionResponse
 */
export const zAgentConfigVersionResponse = z.object({
  id: z.string(),
  kind: z.enum(['build_draft', 'draft', 'snapshot']),
  writable: z.boolean(),
})

/**
 * AgentConfigFileItemResponse
 */
export const zAgentConfigFileItemResponse = z.object({
  file_id: z.string().nullish(),
  hash: z.string().nullish(),
  id: z.string(),
  is_missing: z.boolean().optional().default(false),
  mime_type: z.string().nullish(),
  name: z.string(),
  size: z.int().nullish(),
})

/**
 * AgentConfigFileListResponse
 */
export const zAgentConfigFileListResponse = z.object({
  agent_id: z.string(),
  config_version: zAgentConfigVersionResponse,
  items: z.array(zAgentConfigFileItemResponse).optional(),
})

/**
 * AgentConfigFileUploadResponse
 */
export const zAgentConfigFileUploadResponse = z.object({
  config_version: zAgentConfigVersionResponse,
  file: zAgentConfigFileItemResponse,
})

/**
 * AgentConfigFileItemsResponse
 */
export const zAgentConfigFileItemsResponse = z.object({
  items: z.array(zAgentConfigFileItemResponse).optional(),
})

/**
 * AgentConfigSkillItemResponse
 */
export const zAgentConfigSkillItemResponse = z.object({
  description: z.string().optional().default(''),
  file_id: z.string().nullish(),
  hash: z.string().nullish(),
  id: z.string(),
  is_missing: z.boolean().optional().default(false),
  mime_type: z.string().nullish(),
  name: z.string(),
  size: z.int().nullish(),
})

/**
 * AgentConfigSkillListResponse
 */
export const zAgentConfigSkillListResponse = z.object({
  agent_id: z.string(),
  config_version: zAgentConfigVersionResponse,
  items: z.array(zAgentConfigSkillItemResponse).optional(),
})

/**
 * AgentConfigSkillUploadResponse
 */
export const zAgentConfigSkillUploadResponse = z.object({
  config_version: zAgentConfigVersionResponse,
  skill: zAgentConfigSkillItemResponse,
})

/**
 * AgentConfigSkillItemsResponse
 */
export const zAgentConfigSkillItemsResponse = z.object({
  items: z.array(zAgentConfigSkillItemResponse).optional(),
})

/**
 * AgentConfigManifestResponse
 */
export const zAgentConfigManifestResponse = z.object({
  agent_id: z.string(),
  config_version: zAgentConfigVersionResponse,
  env_keys: z.array(z.string()).optional(),
  files: zAgentConfigFileItemsResponse.optional(),
  note: z.string().optional().default(''),
  skills: zAgentConfigSkillItemsResponse.optional(),
})

/**
 * AgentConfigSkillFileResponse
 */
export const zAgentConfigSkillFileResponse = z.object({
  downloadable: z.boolean(),
  name: z.string(),
  path: z.string(),
  previewable: z.boolean(),
  type: z.enum(['directory', 'file']),
})

/**
 * AgentConfigSkillMarkdownResponse
 */
export const zAgentConfigSkillMarkdownResponse = z.object({
  binary: z.literal(false),
  path: z.literal('SKILL.md'),
  size: z.int().nullish(),
  text: z.string(),
  truncated: z.boolean(),
})

/**
 * AgentConfigSkillInspectResponse
 */
export const zAgentConfigSkillInspectResponse = z.object({
  description: z.string().optional().default(''),
  file_tree: z.array(z.record(z.string(), z.unknown())).nullish(),
  files: z.array(zAgentConfigSkillFileResponse).optional(),
  hash: z.string().nullish(),
  id: z.string(),
  mime_type: z.string().nullish(),
  name: z.string(),
  size: z.int().nullish(),
  skill_md: zAgentConfigSkillMarkdownResponse,
  source: z.literal('config_skill_zip'),
  warnings: z.array(z.string()).optional(),
})

/**
 * AgentDriveItemResponse
 */
export const zAgentDriveItemResponse = z.object({
  created_at: z.int().nullish(),
  file_kind: z.string(),
  hash: z.string().nullish(),
  is_skill: z.boolean().nullish(),
  key: z.string(),
  mime_type: z.string().nullish(),
  size: z.int().nullish(),
  skill_metadata: z.string().nullish(),
})

/**
 * AgentDriveListResponse
 */
export const zAgentDriveListResponse = z.object({
  items: z.array(zAgentDriveItemResponse).optional(),
})

/**
 * AgentDriveSkillItemResponse
 */
export const zAgentDriveSkillItemResponse = z.object({
  archive_key: z.string().nullish(),
  created_at: z.int().nullish(),
  description: z.string(),
  hash: z.string().nullish(),
  mime_type: z.string().nullish(),
  name: z.string(),
  path: z.string(),
  size: z.int().nullish(),
  skill_md_key: z.string(),
})

/**
 * AgentDriveSkillListResponse
 */
export const zAgentDriveSkillListResponse = z.object({
  items: z.array(zAgentDriveSkillItemResponse).optional(),
})

/**
 * AgentDriveSkillFileResponse
 */
export const zAgentDriveSkillFileResponse = z.object({
  available_in_drive: z.boolean(),
  drive_key: z.string().nullish(),
  name: z.string(),
  path: z.string(),
  type: z.string(),
})

/**
 * AgentDriveSkillMarkdownResponse
 */
export const zAgentDriveSkillMarkdownResponse = z.object({
  binary: z.boolean(),
  key: z.string(),
  size: z.int().nullish(),
  text: z.string().nullish(),
  truncated: z.boolean(),
})

/**
 * AgentDriveSkillInspectResponse
 */
export const zAgentDriveSkillInspectResponse = z.object({
  archive_key: z.string().nullish(),
  created_at: z.int().nullish(),
  description: z.string(),
  file_tree: z.array(z.record(z.string(), z.unknown())).optional(),
  files: z.array(zAgentDriveSkillFileResponse).optional(),
  hash: z.string().nullish(),
  mime_type: z.string().nullish(),
  name: z.string(),
  path: z.string(),
  size: z.int().nullish(),
  skill_md: zAgentDriveSkillMarkdownResponse,
  skill_md_key: z.string(),
  source: z.string(),
  warnings: z.array(z.string()).optional(),
})

/**
 * AgentFeatureToggleConfig
 */
export const zAgentFeatureToggleConfig = z.object({
  enabled: z.boolean().optional().default(false),
})

/**
 * AgentTextToSpeechFeatureConfig
 */
export const zAgentTextToSpeechFeatureConfig = z.object({
  autoPlay: z.string().nullish(),
  enabled: z.boolean().optional().default(false),
  language: z.string().nullish(),
  voice: z.string().nullish(),
})

/**
 * AgentDriveFileResponse
 */
export const zAgentDriveFileResponse = z.object({
  drive_key: z.string(),
  file_id: z.string(),
  mime_type: z.string().nullish(),
  name: z.string(),
  size: z.int().nullish(),
})

/**
 * AgentDriveFileCommitResponse
 */
export const zAgentDriveFileCommitResponse = z.object({
  file: zAgentDriveFileResponse,
})

/**
 * AgentLogSourceResponse
 */
export const zAgentLogSourceResponse = z.object({
  app_icon: z.string().nullish(),
  app_icon_background: z.string().nullish(),
  app_icon_type: z.string().nullish(),
  app_id: z.string(),
  app_name: z.string(),
  id: z.string(),
  node_id: z.string().nullish(),
  type: z.enum(['webapp', 'workflow']),
  workflow_id: z.string().nullish(),
  workflow_version: z.string().nullish(),
})

/**
 * AgentLogSourceGroupResponse
 */
export const zAgentLogSourceGroupResponse = z.object({
  label: z.string(),
  sources: z.array(zAgentLogSourceResponse).optional(),
  type: z.enum(['webapp', 'workflow']),
})

/**
 * AgentLogSourceListResponse
 */
export const zAgentLogSourceListResponse = z.object({
  data: z.array(zAgentLogSourceResponse),
  groups: z.array(zAgentLogSourceGroupResponse),
})

/**
 * AgentLogConversationItemResponse
 */
export const zAgentLogConversationItemResponse = z.object({
  conversation_id: z.string(),
  created_at: z.int().nullish(),
  end_user_id: z.string().nullish(),
  id: z.string(),
  message_count: z.int(),
  operation_rate: z.number().nullish(),
  source: zAgentLogSourceResponse.nullish(),
  status: z.enum(['failed', 'paused', 'success']),
  title: z.string().nullish(),
  unread: z.boolean(),
  updated_at: z.int().nullish(),
  user_rate: z.number().nullish(),
})

/**
 * AgentLogListResponse
 */
export const zAgentLogListResponse = z.object({
  data: z.array(zAgentLogConversationItemResponse),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * AgentLogMessageItemResponse
 */
export const zAgentLogMessageItemResponse = z.object({
  answer: z.string(),
  answer_tokens: z.int(),
  conversation_id: z.string(),
  created_at: z.int().nullish(),
  currency: z.string(),
  error: z.string().nullish(),
  from_account_id: z.string().nullish(),
  from_end_user_id: z.string().nullish(),
  id: z.string(),
  latency: z.number(),
  message_id: z.string(),
  message_tokens: z.int(),
  query: z.string(),
  status: z.string(),
  total_price: z.string(),
  total_tokens: z.int(),
  updated_at: z.int().nullish(),
})

/**
 * AgentLogMessageListResponse
 */
export const zAgentLogMessageListResponse = z.object({
  data: z.array(zAgentLogMessageItemResponse),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

export const zJsonValue = z
  .union([
    z.string(),
    z.int(),
    z.number(),
    z.boolean(),
    z.record(z.string(), z.unknown()),
    z.array(z.unknown()),
  ])
  .nullable()

/**
 * AgentThought
 */
export const zAgentThought = z.object({
  answer: z.string().nullish(),
  chain_id: z.string().nullish(),
  created_at: z.int().nullish(),
  files: z.array(z.string()),
  id: z.string(),
  message_id: z.string(),
  observation: z.string().nullish(),
  position: z.int(),
  thought: z.string().nullish(),
  tool: z.string().nullish(),
  tool_input: z.string().nullish(),
  tool_labels: zJsonValue,
})

/**
 * MessageFile
 */
export const zMessageFile = z.object({
  belongs_to: z.string().nullish(),
  filename: z.string(),
  id: z.string(),
  mime_type: z.string().nullish(),
  size: z.int().nullish(),
  transfer_method: z.string(),
  type: z.string(),
  upload_file_id: z.string().nullish(),
  url: z.string().nullish(),
})

/**
 * AgentReferencingWorkflowResponse
 */
export const zAgentReferencingWorkflowResponse = z.object({
  app_icon: z.string().nullish(),
  app_icon_background: z.string().nullish(),
  app_icon_type: z.string().nullish(),
  app_id: z.string(),
  app_mode: z.string(),
  app_name: z.string(),
  app_updated_at: z.int().nullish(),
  node_ids: z.array(z.string()).optional(),
  workflow_id: z.string(),
  workflow_version: z.string(),
})

/**
 * AgentReferencingWorkflowsResponse
 */
export const zAgentReferencingWorkflowsResponse = z.object({
  data: z.array(zAgentReferencingWorkflowResponse).optional(),
})

/**
 * SandboxFileEntryResponse
 */
export const zSandboxFileEntryResponse = z.object({
  mtime: z.int().nullish(),
  name: z.string(),
  size: z.int().nullish(),
  type: z.enum(['dir', 'file', 'other', 'symlink']),
})

/**
 * SandboxListResponse
 */
export const zSandboxListResponse = z.object({
  entries: z.array(zSandboxFileEntryResponse).optional(),
  path: z.string(),
  truncated: z.boolean().optional().default(false),
})

/**
 * SkillManifest
 *
 * Validated metadata extracted from a Skill package.
 */
export const zSkillManifest = z.object({
  description: z.string(),
  entry_path: z.string(),
  files: z.array(z.string()),
  hash: z.string(),
  name: z.string(),
  size: z.int(),
})

/**
 * AgentUploadedSkillResponse
 */
export const zAgentUploadedSkillResponse = z.object({
  archive_key: z.string().nullish(),
  description: z.string(),
  name: z.string(),
  path: z.string(),
  skill_md_key: z.string(),
})

/**
 * AgentSkillUploadResponse
 */
export const zAgentSkillUploadResponse = z.object({
  manifest: zSkillManifest,
  skill: zAgentUploadedSkillResponse,
})

/**
 * AgentStatisticSummaryResponse
 */
export const zAgentStatisticSummaryResponse = z.object({
  average_response_time: z.number(),
  average_session_interactions: z.number(),
  currency: z.string(),
  tokens_per_second: z.number(),
  total_conversations: z.int(),
  total_end_users: z.int(),
  total_messages: z.int(),
  total_price: z.string(),
  total_tokens: z.int(),
  user_satisfaction_rate: z.number(),
})

/**
 * ModelConfigPartial
 */
export const zModelConfigPartial = z.object({
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  model: z.unknown().nullish(),
  pre_prompt: z.string().nullish(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
})

/**
 * AgentAppPublishedReferenceResponse
 */
export const zAgentAppPublishedReferenceResponse = z.object({
  app_icon: z.string().nullish(),
  app_icon_background: z.string().nullish(),
  app_icon_type: z.string().nullish(),
  app_id: z.string(),
  app_name: z.string(),
})

/**
 * AgentAppPartial
 */
export const zAgentAppPartial = z.object({
  access_mode: z.string().nullish(),
  active_config_is_published: z.boolean().optional().default(false),
  app_id: z.string().nullish(),
  author_name: z.string().nullish(),
  backing_app_id: z.string().nullish(),
  bound_agent_id: z.string().nullish(),
  create_user_name: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  debug_conversation_id: z.string().nullish(),
  description: z.string().nullish(),
  has_draft_trigger: z.boolean().nullish(),
  hidden_app_backed: z.boolean().optional().default(false),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  icon_url: z.string().nullable(),
  id: z.string(),
  is_starred: z.boolean().optional().default(false),
  maintainer: z.string().nullish(),
  max_active_requests: z.int().nullish(),
  mode: z.string(),
  model_config: zModelConfigPartial.nullish(),
  name: z.string(),
  permission_keys: z.array(z.string()).optional(),
  published_reference_count: z.int().optional().default(0),
  published_references: z.array(zAgentAppPublishedReferenceResponse).optional(),
  reference_count: z.int().nullish(),
  role: z.string().nullish(),
  tags: z.array(zTag).optional(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
  use_icon_as_answer_icon: z.boolean().nullish(),
  workflow: zWorkflowPartial.nullish(),
})

/**
 * AgentAppPagination
 */
export const zAgentAppPagination = z.object({
  data: z.array(zAgentAppPartial),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * LLMMode
 *
 * Enum class for large language model mode.
 */
export const zLlmMode = z.enum(['chat', 'completion'])

/**
 * ModelConfig
 */
export const zModelConfig = z.object({
  completion_params: z.record(z.string(), z.unknown()).optional(),
  mode: zLlmMode,
  name: z.string(),
  provider: z.string(),
})

/**
 * AgentAppDetailWithSite
 */
export const zAgentAppDetailWithSite = z.object({
  access_mode: z.string().nullish(),
  active_config_is_published: z.boolean().optional().default(false),
  api_base_url: z.string().nullish(),
  app_id: z.string().nullish(),
  backing_app_id: z.string().nullish(),
  bound_agent_id: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  debug_conversation_has_messages: z.boolean().optional().default(false),
  debug_conversation_id: z.string().nullish(),
  debug_conversation_message_count: z.int().optional().default(0),
  deleted_tools: z.array(zDeletedTool).optional(),
  description: z.string().nullish(),
  enable_api: z.boolean(),
  enable_site: z.boolean(),
  hidden_app_backed: z.boolean().optional().default(false),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  icon_url: z.string().nullable(),
  id: z.string(),
  maintainer: z.string().nullish(),
  max_active_requests: z.int().nullish(),
  mode: z.string(),
  model_config: zModelConfig.nullish(),
  name: z.string(),
  permission_keys: z.array(z.string()).optional(),
  role: z.string().nullish(),
  site: zAppDetailSiteResponse.nullish(),
  tags: z.array(zTag).optional(),
  tracing: z.unknown().nullish(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
  use_icon_as_answer_icon: z.boolean().nullish(),
  workflow: zWorkflowPartial.nullish(),
})

/**
 * AgentKind
 *
 * Agent implementation family.
 *
 * This leaves room for future non-Dify agent implementations while keeping
 * the current roster/workflow APIs scoped to Dify Agent.
 */
export const zAgentKind = z.enum(['dify_agent'])

/**
 * AgentPublishedReferenceResponse
 */
export const zAgentPublishedReferenceResponse = z.object({
  app_icon: z.string().nullish(),
  app_icon_background: z.string().nullish(),
  app_icon_type: z.string().nullish(),
  app_id: z.string(),
  app_mode: z.string(),
  app_name: z.string(),
  app_updated_at: z.int().nullish(),
  node_ids: z.array(z.string()).optional(),
  workflow_id: z.string(),
  workflow_version: z.string(),
})

/**
 * AgentScope
 *
 * Visibility and lifecycle scope of an Agent record.
 */
export const zAgentScope = z.enum(['roster', 'workflow_only'])

/**
 * AgentSource
 *
 * Origin that created or imported the Agent.
 */
export const zAgentSource = z.enum(['agent_app', 'imported', 'roster', 'system', 'workflow'])

/**
 * AgentStatus
 *
 * Soft lifecycle state for Agent records.
 */
export const zAgentStatus = z.enum(['active', 'archived'])

/**
 * AgentInviteOptionResponse
 */
export const zAgentInviteOptionResponse = z.object({
  active_config_is_published: z.boolean().optional().default(false),
  active_config_snapshot: zAgentConfigSnapshotSummaryResponse.nullish(),
  active_config_snapshot_id: z.string().nullish(),
  agent_kind: zAgentKind,
  app_id: z.string().nullish(),
  archived_at: z.int().nullish(),
  archived_by: z.string().nullish(),
  backing_app_id: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  description: z.string(),
  existing_node_ids: z.array(z.string()).optional(),
  hidden_app_backed: z.boolean().optional().default(false),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: zAgentIconType.nullish(),
  id: z.string(),
  in_current_workflow_count: z.int().optional().default(0),
  is_in_current_workflow: z.boolean().optional().default(false),
  name: z.string(),
  published_node_reference_count: z.int().optional().default(0),
  published_reference_count: z.int().optional().default(0),
  published_references: z.array(zAgentPublishedReferenceResponse).optional(),
  reference_count: z.int().nullish(),
  role: z.string().optional().default(''),
  scope: zAgentScope,
  source: zAgentSource,
  status: zAgentStatus,
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
  workflow_id: z.string().nullish(),
  workflow_node_id: z.string().nullish(),
})

/**
 * AgentInviteOptionsResponse
 */
export const zAgentInviteOptionsResponse = z.object({
  data: z.array(zAgentInviteOptionResponse),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * AgentComposerAgentResponse
 */
export const zAgentComposerAgentResponse = z.object({
  active_config_snapshot_id: z.string().nullish(),
  app_id: z.string().nullish(),
  backing_app_id: z.string().nullish(),
  description: z.string(),
  hidden_app_backed: z.boolean().optional().default(false),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  id: z.string(),
  name: z.string(),
  role: z.string().nullish(),
  scope: zAgentScope,
  source: zAgentSource.nullish(),
  status: zAgentStatus,
})

/**
 * AppVariableConfig
 */
export const zAppVariableConfig = z.object({
  default: z.unknown().optional(),
  name: z.string().min(1).max(255),
  required: z.boolean().optional().default(false),
  type: z.string().min(1).max(64),
})

/**
 * AgentConfigFileRefConfig
 *
 * Stable Agent Soul reference to one config file payload.
 */
export const zAgentConfigFileRefConfig = z.object({
  file_id: z.string().max(255).optional().default(''),
  file_kind: z.enum(['tool_file', 'upload_file']),
  hash: z.string().nullish(),
  is_missing: z.boolean().optional().default(false),
  mime_type: z.string().nullish(),
  name: z.string().min(1).max(255),
  size: z.int().nullish(),
})

/**
 * AgentConfigSkillRefConfig
 *
 * Stable Agent Soul reference to one normalized skill archive.
 */
export const zAgentConfigSkillRefConfig = z.object({
  description: z.string().optional().default(''),
  file_id: z.string().max(255).optional().default(''),
  file_kind: z.literal('tool_file').optional().default('tool_file'),
  hash: z.string().nullish(),
  is_missing: z.boolean().optional().default(false),
  mime_type: z.string().nullish().default('application/zip'),
  name: z.string().min(1).max(255),
  size: z.int().nullish(),
})

/**
 * AgentSoulPromptConfig
 */
export const zAgentSoulPromptConfig = z.object({
  system_prompt: z.string().optional().default(''),
})

/**
 * AgentConfigDraftType
 *
 * Editable Agent Soul draft workspace type.
 */
export const zAgentConfigDraftType = z.enum(['debug_build', 'draft'])

/**
 * AgentConfigDraftSummaryResponse
 */
export const zAgentConfigDraftSummaryResponse = z.object({
  account_id: z.string().nullish(),
  agent_id: z.string(),
  base_snapshot_id: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  draft_type: zAgentConfigDraftType,
  id: z.string(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
})

/**
 * AgentPublishResponse
 */
export const zAgentPublishResponse = z.object({
  active_config_snapshot: zAgentConfigSnapshotSummaryResponse.nullish(),
  active_config_snapshot_id: z.string(),
  draft: zAgentConfigDraftSummaryResponse.nullish(),
  result: z.string(),
})

/**
 * AgentHumanContactConfig
 */
export const zAgentHumanContactConfig = z.object({
  channel: z.string().max(64).nullish(),
  contact_id: z.string().max(255).nullish(),
  contact_method: z.string().max(64).nullish(),
  email: z.string().max(255).nullish(),
  human_id: z.string().max(255).nullish(),
  id: z.string().max(255).nullish(),
  method: z.string().max(64).nullish(),
  name: z.string().max(255).nullish(),
  tenant_id: z.string().max(255).nullish(),
})

/**
 * WorkflowNodeJobMode
 */
export const zWorkflowNodeJobMode = z.enum(['let_agent_figure_it_out', 'tell_agent_what_to_do'])

/**
 * WorkflowPreviousNodeOutputRef
 */
export const zWorkflowPreviousNodeOutputRef = z.object({
  key: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  node_id: z.string().max(255).nullish(),
  output: z.string().max(255).nullish(),
  selector: z.array(z.union([z.string(), z.int(), z.number(), z.boolean(), z.null()])).nullish(),
  value_selector: z
    .array(z.union([z.string(), z.int(), z.number(), z.boolean(), z.null()]))
    .nullish(),
  variable: z.string().max(255).nullish(),
  variable_selector: z
    .array(z.union([z.string(), z.int(), z.number(), z.boolean(), z.null()]))
    .nullish(),
})

/**
 * DeclaredOutputType
 */
export const zDeclaredOutputType = z.enum([
  'array',
  'boolean',
  'file',
  'number',
  'object',
  'string',
])

/**
 * AgentComposerNodeJobCandidatesResponse
 */
export const zAgentComposerNodeJobCandidatesResponse = z.object({
  declare_output_types: z.array(zDeclaredOutputType).optional(),
  human_contacts: z.array(zAgentHumanContactConfig).optional(),
  previous_node_outputs: z.array(zWorkflowPreviousNodeOutputRef).optional(),
})

/**
 * AgentComposerDifyToolCandidateResponse
 */
export const zAgentComposerDifyToolCandidateResponse = z.object({
  description: z.string().nullish(),
  granularity: z.string().nullish(),
  id: z.string().nullish(),
  name: z.string().nullish(),
  plugin_id: z.string().nullish(),
  provider: z.string().nullish(),
  provider_id: z.string().nullish(),
  tools_count: z.int().nullish(),
})

/**
 * AgentSuggestedQuestionsAfterAnswerModelConfig
 *
 * Legacy Chat App model config used only for follow-up question generation.
 */
export const zAgentSuggestedQuestionsAfterAnswerModelConfig = z.object({
  completion_params: z.record(z.string(), z.unknown()).nullish(),
  mode: z.string().max(64).nullish(),
  name: z.string().min(1).max(255),
  provider: z.string().min(1).max(255),
})

/**
 * AgentSuggestedQuestionsAfterAnswerFeatureConfig
 */
export const zAgentSuggestedQuestionsAfterAnswerFeatureConfig = z.object({
  enabled: z.boolean().optional().default(false),
  model: zAgentSuggestedQuestionsAfterAnswerModelConfig.nullish(),
  prompt: z.string().nullish(),
})

/**
 * SimpleAccount
 */
export const zSimpleAccount = z.object({
  email: z.string(),
  id: z.string(),
  name: z.string(),
})

/**
 * ConversationAnnotation
 */
export const zConversationAnnotation = z.object({
  account: zSimpleAccount.nullish(),
  content: z.string(),
  created_at: z.int().nullish(),
  id: z.string(),
  question: z.string().nullish(),
})

/**
 * ConversationAnnotationHitHistory
 */
export const zConversationAnnotationHitHistory = z.object({
  annotation_create_account: zSimpleAccount.nullish(),
  annotation_id: z.string(),
  created_at: z.int().nullish(),
})

/**
 * Feedback
 */
export const zFeedback = z.object({
  content: z.string().nullish(),
  from_account: zSimpleAccount.nullish(),
  from_end_user_id: z.string().nullish(),
  from_source: z.string(),
  rating: z.string(),
})

/**
 * ExecutionContentType
 */
export const zExecutionContentType = z.enum(['human_input'])

/**
 * EnvSuggestion
 */
export const zEnvSuggestion = z.object({
  key: z.string(),
  reason: z.string().optional().default(''),
  secret_likely: z.boolean().optional().default(false),
})

/**
 * CliToolSuggestion
 */
export const zCliToolSuggestion = z.object({
  command: z.string().optional().default(''),
  description: z.string().optional().default(''),
  env_suggestions: z.array(zEnvSuggestion).optional(),
  inferred_from: z.string().optional().default(''),
  install_commands: z.array(z.string()).optional(),
  name: z.string(),
})

/**
 * SkillToolInferenceResult
 */
export const zSkillToolInferenceResult = z.object({
  cli_tools: z.array(zCliToolSuggestion).optional(),
  inferable: z.boolean(),
  reason: z.string().nullish(),
})

/**
 * AgentAverageResponseTimeStatisticResponse
 */
export const zAgentAverageResponseTimeStatisticResponse = z.object({
  date: z.string(),
  latency: z.number(),
})

/**
 * AgentAverageSessionInteractionStatisticResponse
 */
export const zAgentAverageSessionInteractionStatisticResponse = z.object({
  date: z.string(),
  interactions: z.number(),
})

/**
 * AgentDailyConversationStatisticResponse
 */
export const zAgentDailyConversationStatisticResponse = z.object({
  conversation_count: z.int(),
  date: z.string(),
})

/**
 * AgentDailyEndUserStatisticResponse
 */
export const zAgentDailyEndUserStatisticResponse = z.object({
  date: z.string(),
  terminal_count: z.int(),
})

/**
 * AgentDailyMessageStatisticResponse
 */
export const zAgentDailyMessageStatisticResponse = z.object({
  date: z.string(),
  message_count: z.int(),
})

/**
 * AgentTokenUsageStatisticResponse
 */
export const zAgentTokenUsageStatisticResponse = z.object({
  currency: z.string(),
  date: z.string(),
  token_count: z.int(),
  total_price: z.string(),
})

/**
 * AgentTokensPerSecondStatisticResponse
 */
export const zAgentTokensPerSecondStatisticResponse = z.object({
  date: z.string(),
  tps: z.number(),
})

/**
 * AgentUserSatisfactionRateStatisticResponse
 */
export const zAgentUserSatisfactionRateStatisticResponse = z.object({
  date: z.string(),
  rate: z.number(),
})

/**
 * AgentStatisticChartsResponse
 */
export const zAgentStatisticChartsResponse = z.object({
  average_response_time: z.array(zAgentAverageResponseTimeStatisticResponse).optional(),
  average_session_interactions: z
    .array(zAgentAverageSessionInteractionStatisticResponse)
    .optional(),
  daily_conversations: z.array(zAgentDailyConversationStatisticResponse).optional(),
  daily_end_users: z.array(zAgentDailyEndUserStatisticResponse).optional(),
  daily_messages: z.array(zAgentDailyMessageStatisticResponse).optional(),
  token_usage: z.array(zAgentTokenUsageStatisticResponse).optional(),
  tokens_per_second: z.array(zAgentTokensPerSecondStatisticResponse).optional(),
  user_satisfaction_rate: z.array(zAgentUserSatisfactionRateStatisticResponse).optional(),
})

/**
 * AgentStatisticSummaryEnvelopeResponse
 */
export const zAgentStatisticSummaryEnvelopeResponse = z.object({
  charts: zAgentStatisticChartsResponse,
  source: z.string(),
  summary: zAgentStatisticSummaryResponse,
})

/**
 * AgentConfigRevisionOperation
 *
 * Audit operation recorded for Agent Soul version/revision changes.
 */
export const zAgentConfigRevisionOperation = z.enum([
  'create_version',
  'import_package',
  'publish_draft',
  'restore_version',
  'save_current_version',
  'save_new_agent',
  'save_new_version',
  'save_to_roster',
])

/**
 * AgentConfigRevisionResponse
 */
export const zAgentConfigRevisionResponse = z.object({
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  current_snapshot_id: z.string(),
  id: z.string(),
  operation: zAgentConfigRevisionOperation,
  previous_snapshot_id: z.string().nullish(),
  revision: z.int(),
  summary: z.string().nullish(),
  version_note: z.string().nullish(),
})

/**
 * AgentEnvVariableConfig
 */
export const zAgentEnvVariableConfig = z.object({
  default: z
    .union([
      z.string(),
      z.int(),
      z.number(),
      z.boolean(),
      z.array(z.string()),
      z.array(z.int()),
      z.array(z.number()),
      z.array(z.boolean()),
    ])
    .nullish(),
  env_name: z.string().max(255).nullish(),
  key: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  required: z.boolean().optional().default(false),
  type: z.string().max(64).nullish(),
  value: z
    .union([
      z.string(),
      z.int(),
      z.number(),
      z.boolean(),
      z.array(z.string()),
      z.array(z.int()),
      z.array(z.number()),
      z.array(z.boolean()),
    ])
    .nullish(),
  variable: z.string().max(255).nullish(),
})

/**
 * AgentFileRefConfig
 */
export const zAgentFileRefConfig = z.object({
  drive_key: z.string().max(512).nullish(),
  file_id: z.string().max(255).nullish(),
  id: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  reference: z.string().max(255).nullish(),
  remote_url: z.string().nullish(),
  tenant_id: z.string().max(255).nullish(),
  transfer_method: z.string().max(64).nullish(),
  type: z.string().max(64).nullish(),
  upload_file_id: z.string().max(255).nullish(),
  url: z.string().nullish(),
})

/**
 * WorkflowNodeJobMetadata
 */
export const zWorkflowNodeJobMetadata = z.object({
  agent_soul: z.record(z.string(), z.unknown()).nullish(),
  file_refs: z.array(zAgentFileRefConfig).nullish(),
})

/**
 * AgentSkillRefConfig
 */
export const zAgentSkillRefConfig = z.object({
  description: z.string().nullish(),
  file_id: z.string().max(255).nullish(),
  full_archive_file_id: z.string().max(255).nullish(),
  full_archive_key: z.string().max(512).nullish(),
  id: z.string().max(255).nullish(),
  manifest_files: z.array(z.string()).nullish(),
  name: z.string().max(255).nullish(),
  path: z.string().nullish(),
  skill_md_file_id: z.string().max(255).nullish(),
  skill_md_key: z.string().max(512).nullish(),
})

/**
 * AgentSoulFilesConfig
 */
export const zAgentSoulFilesConfig = z.object({
  files: z.array(zAgentFileRefConfig).optional(),
  skills: z.array(zAgentSkillRefConfig).optional(),
})

/**
 * AgentHumanToolConfig
 */
export const zAgentHumanToolConfig = z.object({
  description: z.string().nullish(),
  enabled: z.boolean().optional().default(true),
  name: z.string().max(255).nullish(),
})

/**
 * AgentSoulHumanConfig
 */
export const zAgentSoulHumanConfig = z.object({
  contacts: z.array(zAgentHumanContactConfig).optional(),
  tools: z.array(zAgentHumanToolConfig).optional(),
})

/**
 * AgentMemoryArtifactConfig
 */
export const zAgentMemoryArtifactConfig = z.object({
  id: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  type: z.string().max(64).nullish(),
  url: z.string().nullish(),
})

/**
 * AgentSoulMemoryConfig
 */
export const zAgentSoulMemoryConfig = z.object({
  artifacts: z.array(zAgentMemoryArtifactConfig).optional(),
  budget: z.string().nullish(),
  scope: z.string().nullish(),
})

/**
 * AgentSoulModelCredentialRef
 *
 * Reference to model credentials resolved only at runtime.
 */
export const zAgentSoulModelCredentialRef = z.object({
  id: z.string().max(255).nullish(),
  provider: z.string().max(255).nullish(),
  type: z.string().min(1).max(64),
})

/**
 * AgentSandboxProviderConfig
 */
export const zAgentSandboxProviderConfig = z.object({
  cpu: z.int().gte(1).nullish(),
  env: z.array(zAgentEnvVariableConfig).optional(),
  image: z.string().nullish(),
  working_dir: z.string().nullish(),
})

/**
 * AgentSoulSandboxConfig
 */
export const zAgentSoulSandboxConfig = z.object({
  config: zAgentSandboxProviderConfig.optional(),
  provider: z.string().nullish(),
})

/**
 * DeclaredArrayItem
 *
 * Per-item shape for an ``array``-typed declared output.
 *
 * PRD §OUTPUT 配置框 keeps arrays one level deep on first version; nested arrays
 * are rejected so the runtime type checker and JSON Schema stay easy to reason
 * about. Stage 4 §4.2.
 */
export const zDeclaredArrayItem = z.object({
  children: z
    .array(
      z.object({
        array_item: z
          .object({
            children: z.array(z.record(z.string(), z.unknown())).optional(),
            description: z.string().nullish(),
            type: z.enum(['array', 'boolean', 'file', 'number', 'object', 'string']).optional(),
          })
          .optional(),
        children: z.array(z.record(z.string(), z.unknown())).optional(),
        description: z.string().nullish(),
        file: z.record(z.string(), z.unknown()).optional(),
        name: z.string(),
        required: z.boolean().optional(),
        type: z.enum(['array', 'boolean', 'file', 'number', 'object', 'string']),
      }),
    )
    .optional(),
  description: z.string().nullish(),
  type: zDeclaredOutputType,
})

/**
 * DeclaredOutputFileConfig
 *
 * File-type output metadata. Both lists empty means "any file accepted".
 */
export const zDeclaredOutputFileConfig = z.object({
  extensions: z.array(z.string()).optional(),
  mime_types: z.array(z.string()).optional(),
})

/**
 * AgentCliToolAuthorizationStatus
 *
 * Authorization state for Agent-scoped CLI tools.
 *
 * Missing status keeps backward compatibility with draft rows and CLI tools that
 * do not need pre-authorization. Explicit denied-like states are blocked by the
 * composer/publish validators and skipped by runtime request builders.
 */
export const zAgentCliToolAuthorizationStatus = z.enum([
  'allowed',
  'authorized',
  'denied',
  'forbidden',
  'not_required',
  'pending',
  'pre_authorized',
  'unauthorized',
])

/**
 * AgentPermissionConfig
 */
export const zAgentPermissionConfig = z.object({
  allowed: z.boolean().nullish(),
  state: z.string().max(64).nullish(),
  status: z.string().max(64).nullish(),
})

/**
 * AgentSecretRefConfig
 */
export const zAgentSecretRefConfig = z.object({
  credential_id: z.string().max(255).nullish(),
  env_name: z.string().max(255).nullish(),
  id: z.string().max(255).nullish(),
  key: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  permission: zAgentPermissionConfig.nullish(),
  permission_status: z.string().max(64).nullish(),
  provider: z.string().max(255).nullish(),
  provider_credential_id: z.string().max(255).nullish(),
  ref: z.string().max(255).nullish(),
  type: z.string().max(64).nullish(),
  value: z.string().nullish(),
  variable: z.string().max(255).nullish(),
})

/**
 * AgentSoulEnvConfig
 */
export const zAgentSoulEnvConfig = z.object({
  secret_refs: z.array(zAgentSecretRefConfig).optional(),
  variables: z.array(zAgentEnvVariableConfig).optional(),
})

/**
 * AgentCliToolEnvConfig
 */
export const zAgentCliToolEnvConfig = z.object({
  secret_refs: z.array(zAgentSecretRefConfig).optional(),
  variables: z.array(zAgentEnvVariableConfig).optional(),
})

/**
 * AgentCliToolRiskLevel
 *
 * Risk marker for CLI tool bootstrap commands.
 */
export const zAgentCliToolRiskLevel = z.enum(['dangerous', 'safe', 'unknown'])

/**
 * AgentCliToolConfig
 */
export const zAgentCliToolConfig = z.object({
  approved: z.boolean().optional().default(false),
  authorization_status: zAgentCliToolAuthorizationStatus.nullish(),
  command: z.string().nullish(),
  dangerous: z.boolean().optional().default(false),
  dangerous_accepted: z.boolean().optional().default(false),
  dangerous_acknowledged: z.boolean().optional().default(false),
  dangerous_command: z.boolean().optional().default(false),
  description: z.string().nullish(),
  enabled: z.boolean().optional().default(true),
  env: zAgentCliToolEnvConfig.optional(),
  id: z.string().max(255).nullish(),
  inferred_from: z.string().max(255).nullish(),
  install: z.string().nullish(),
  install_command: z.string().nullish(),
  install_commands: z.array(z.string()).optional(),
  invoke_metadata: z.record(z.string(), z.unknown()).optional(),
  label: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
  permission: zAgentPermissionConfig.nullish(),
  pre_authorized: z.boolean().nullish(),
  requires_confirmation: z.boolean().optional().default(false),
  risk_accepted: z.boolean().optional().default(false),
  risk_level: zAgentCliToolRiskLevel.nullish(),
  setup_command: z.string().nullish(),
  tool_name: z.string().max(255).nullish(),
})

/**
 * AgentComposerKnowledgeDatasetCandidateResponse
 */
export const zAgentComposerKnowledgeDatasetCandidateResponse = z.object({
  description: z.string().nullish(),
  id: z.string().max(255).nullish(),
  missing: z.boolean().optional().default(false),
  name: z.string().max(255).nullish(),
})

/**
 * AgentComposerKnowledgeSetCandidateResponse
 */
export const zAgentComposerKnowledgeSetCandidateResponse = z.object({
  datasets: z.array(zAgentComposerKnowledgeDatasetCandidateResponse).optional(),
  description: z.string().nullish(),
  id: z.string(),
  missing_dataset_ids: z.array(z.string()).optional(),
  name: z.string(),
})

/**
 * AgentComposerSoulCandidatesResponse
 */
export const zAgentComposerSoulCandidatesResponse = z.object({
  cli_tools: z.array(zAgentCliToolConfig).optional(),
  dify_tools: z.array(zAgentComposerDifyToolCandidateResponse).optional(),
  human_contacts: z.array(zAgentHumanContactConfig).optional(),
  knowledge_sets: z.array(zAgentComposerKnowledgeSetCandidateResponse).optional(),
})

/**
 * AgentComposerCandidatesResponse
 */
export const zAgentComposerCandidatesResponse = z.object({
  allowed_node_job_candidates: zAgentComposerNodeJobCandidatesResponse.optional(),
  allowed_soul_candidates: zAgentComposerSoulCandidatesResponse.optional(),
  capabilities: zComposerCandidateCapabilities.optional(),
  truncated: z.boolean().optional().default(false),
  variant: zComposerVariant,
})

/**
 * AgentModerationIOConfig
 */
export const zAgentModerationIoConfig = z.object({
  enabled: z.boolean().optional().default(false),
  preset_response: z.string().nullish(),
})

/**
 * AgentModerationProviderConfig
 */
export const zAgentModerationProviderConfig = z.object({
  api_based_extension_id: z.string().nullish(),
  inputs_config: zAgentModerationIoConfig.nullish(),
  keywords: z.string().nullish(),
  outputs_config: zAgentModerationIoConfig.nullish(),
})

/**
 * AgentSensitiveWordAvoidanceFeatureConfig
 */
export const zAgentSensitiveWordAvoidanceFeatureConfig = z.object({
  config: zAgentModerationProviderConfig.nullish(),
  enabled: z.boolean().optional().default(false),
  type: z.string().nullish(),
})

/**
 * AgentAppFeaturesPayload
 *
 * Presentation features configurable on an Agent App.
 *
 * All fields are optional; an omitted field is reset to its disabled/empty
 * default (the config form sends the full desired feature state on save).
 */
export const zAgentAppFeaturesPayload = z.object({
  opening_statement: z.string().nullish(),
  retriever_resource: zAgentFeatureToggleConfig.nullish(),
  sensitive_word_avoidance: zAgentSensitiveWordAvoidanceFeatureConfig.nullish(),
  speech_to_text: zAgentFeatureToggleConfig.nullish(),
  suggested_questions: z.array(z.string()).nullish(),
  suggested_questions_after_answer: zAgentSuggestedQuestionsAfterAnswerFeatureConfig.nullish(),
  text_to_speech: zAgentTextToSpeechFeatureConfig.nullish(),
})

export const zJsonValue2 = z.unknown()

/**
 * HumanInputFormSubmissionData
 */
export const zHumanInputFormSubmissionData = z.object({
  action_id: z.string(),
  action_text: z.string(),
  node_id: z.string(),
  node_title: z.string(),
  rendered_content: z.string(),
  submitted_data: z.record(z.string(), zJsonValue2).nullish(),
})

/**
 * FileType
 */
export const zFileType = z.enum(['audio', 'custom', 'document', 'image', 'video'])

/**
 * FileTransferMethod
 */
export const zFileTransferMethod = z.enum([
  'datasource_file',
  'local_file',
  'remote_url',
  'tool_file',
])

/**
 * AgentFileUploadImageFeatureConfig
 */
export const zAgentFileUploadImageFeatureConfig = z.object({
  enabled: z.boolean().optional().default(true),
})

/**
 * AgentFileUploadFeatureConfig
 */
export const zAgentFileUploadFeatureConfig = z.object({
  allowed_file_extensions: z.array(z.string()).optional(),
  allowed_file_types: z.array(zFileType).optional(),
  allowed_file_upload_methods: z.array(zFileTransferMethod).optional(),
  enabled: z.boolean().optional().default(true),
  image: zAgentFileUploadImageFeatureConfig.optional(),
  number_limits: z.int().optional().default(3),
})

/**
 * AgentSoulAppFeaturesConfig
 */
export const zAgentSoulAppFeaturesConfig = z.object({
  file_upload: zAgentFileUploadFeatureConfig.optional(),
  opening_statement: z.string().nullish(),
  retriever_resource: zAgentFeatureToggleConfig.nullish(),
  sensitive_word_avoidance: zAgentSensitiveWordAvoidanceFeatureConfig.nullish(),
  speech_to_text: zAgentFeatureToggleConfig.nullish(),
  suggested_questions: z.array(z.string()).nullish(),
  suggested_questions_after_answer: zAgentSuggestedQuestionsAfterAnswerFeatureConfig.nullish(),
  text_to_speech: zAgentTextToSpeechFeatureConfig.nullish(),
})

/**
 * AgentKnowledgeDatasetConfig
 */
export const zAgentKnowledgeDatasetConfig = z.object({
  description: z.string().nullish(),
  id: z.string().max(255).nullish(),
  name: z.string().max(255).nullish(),
})

/**
 * AgentModelResponseFormatConfig
 */
export const zAgentModelResponseFormatConfig = z.object({
  type: z.string().max(64).nullish(),
})

/**
 * AgentSoulModelSettings
 */
export const zAgentSoulModelSettings = z.object({
  frequency_penalty: z.number().nullish(),
  max_tokens: z.int().nullish(),
  presence_penalty: z.number().nullish(),
  response_format: zAgentModelResponseFormatConfig.nullish(),
  stop: z.array(z.string()).nullish(),
  temperature: z.number().nullish(),
  top_p: z.number().nullish(),
})

/**
 * AgentSoulModelConfig
 *
 * Stable model selection for Agent runtime without storing secret values.
 */
export const zAgentSoulModelConfig = z.object({
  credential_ref: zAgentSoulModelCredentialRef.nullish(),
  model: z.string().min(1).max(255),
  model_provider: z.string().min(1).max(255),
  model_settings: zAgentSoulModelSettings.optional(),
  plugin_id: z.string().min(1).max(255),
})

/**
 * DeclaredOutputCheckConfig
 *
 * File-output content check via a model-based comparison against a benchmark file.
 *
 * Per PRD §OUTPUT 配置框, output check is **file-only** and optional. Stage 4 §4.3.
 */
export const zDeclaredOutputCheckConfig = z.object({
  benchmark_file_ref: zAgentFileRefConfig.nullish(),
  enabled: z.boolean().optional().default(false),
  model_ref: zAgentSoulModelConfig.nullish(),
  prompt: z.string().nullish(),
})

/**
 * AgentSoulDifyToolCredentialRef
 *
 * Reference to a stored Dify Plugin Tool credential.
 *
 * Secret values are resolved only at runtime. The legacy ``credential_id``
 * field is accepted by :class:`AgentSoulDifyToolConfig` and normalized here so
 * old Agent tool payloads can be read while new payloads stay explicit.
 */
export const zAgentSoulDifyToolCredentialRef = z.object({
  id: z.string().max(255).nullish(),
  provider: z.string().max(255).nullish(),
  type: z.enum(['provider', 'tool']).optional().default('tool'),
})

/**
 * ToolProviderType
 *
 * Enum class for tool provider
 */
export const zToolProviderType = z.enum([
  'api',
  'app',
  'builtin',
  'dataset-retrieval',
  'mcp',
  'plugin',
  'workflow',
])

/**
 * AgentSoulDifyToolConfig
 *
 * One Dify tool configured on Agent Soul.
 *
 * The API backend prepares this persisted product shape into
 * either ``DifyPluginToolConfig`` or ``DifyCoreToolConfig`` before sending a
 * run request to Agent backend. ``plugin`` providers keep the direct
 * ``dify.plugin.tools`` transport; ``builtin`` / ``api`` / ``workflow`` /
 * ``mcp`` providers are prepared for ``dify.core.tools``. ``provider_id``
 * keeps compatibility with existing Agent tool config payloads; new callers
 * should send ``plugin_id`` + ``provider`` when available.
 */
export const zAgentSoulDifyToolConfig = z.object({
  credential_ref: zAgentSoulDifyToolCredentialRef.nullish(),
  credential_type: z.enum(['api-key', 'oauth2', 'unauthorized']).optional().default('api-key'),
  description: z.string().nullish(),
  enabled: z.boolean().optional().default(true),
  name: z.string().max(255).nullish(),
  plugin_id: z.string().max(255).nullish(),
  provider: z.string().max(255).nullish(),
  provider_id: z.string().max(255).nullish(),
  provider_type: zToolProviderType,
  runtime_parameters: z
    .record(
      z.string(),
      z
        .union([
          z.string(),
          z.int(),
          z.number(),
          z.boolean(),
          z.array(z.string()),
          z.array(z.int()),
          z.array(z.number()),
          z.array(z.boolean()),
        ])
        .nullable(),
    )
    .optional(),
  tool_name: z.string().min(1).max(255).nullish(),
})

/**
 * AgentSoulToolsConfig
 */
export const zAgentSoulToolsConfig = z.object({
  cli_tools: z.array(zAgentCliToolConfig).optional(),
  dify_tools: z.array(zAgentSoulDifyToolConfig).optional(),
})

/**
 * OutputErrorStrategy
 *
 * Per-output failure handling strategy.
 *
 * Mirrors ``graphon.ErrorStrategy`` but scoped to a single declared output of
 * a Workflow Agent Node. The runtime applies the strategy after type check or
 * output check fails and any configured retry attempts have been exhausted.
 */
export const zOutputErrorStrategy = z.enum(['default_value', 'fail_branch', 'stop'])

/**
 * DeclaredOutputRetryConfig
 *
 * Per-output retry configuration that mirrors ``graphon.RetryConfig`` shape.
 */
export const zDeclaredOutputRetryConfig = z.object({
  enabled: z.boolean().optional().default(false),
  max_retries: z.int().gte(0).lte(10).optional().default(0),
  retry_interval_ms: z.int().gte(0).lte(60000).optional().default(0),
})

/**
 * DeclaredOutputFailureStrategy
 *
 * Per-output failure handling.
 *
 * A single strategy applies to both ``type_check`` and ``output_check`` failures
 * (PRD does not distinguish them at the UX level). Stage 4 §4.4.
 */
export const zDeclaredOutputFailureStrategy = z.object({
  default_value: z.unknown().optional(),
  on_failure: zOutputErrorStrategy.optional().default('stop'),
  retry: zDeclaredOutputRetryConfig.optional(),
})

/**
 * DeclaredOutputConfig
 *
 * One declared output of a Workflow Agent Node.
 *
 * Stage 4 normalizes the shape: ``check`` is singular (was ``checks: list`` in
 * stage 3), and ``failure_strategy`` defaults to a populated value so runtime
 * code can call ``output.failure_strategy.on_failure`` without None-guards.
 */
export const zDeclaredOutputConfig = z.object({
  array_item: zDeclaredArrayItem.nullish(),
  check: zDeclaredOutputCheckConfig.nullish(),
  children: z
    .array(
      z.object({
        array_item: z
          .object({
            children: z.array(z.record(z.string(), z.unknown())).optional(),
            description: z.string().nullish(),
            type: z.enum(['array', 'boolean', 'file', 'number', 'object', 'string']).optional(),
          })
          .optional(),
        children: z.array(z.record(z.string(), z.unknown())).optional(),
        description: z.string().nullish(),
        file: z.record(z.string(), z.unknown()).optional(),
        name: z.string(),
        required: z.boolean().optional(),
        type: z.enum(['array', 'boolean', 'file', 'number', 'object', 'string']),
      }),
    )
    .optional(),
  description: z.string().nullish(),
  failure_strategy: zDeclaredOutputFailureStrategy.optional(),
  file: zDeclaredOutputFileConfig.nullish(),
  id: z.string().nullish(),
  name: z.string().min(1).max(255),
  required: z.boolean().optional().default(true),
  type: zDeclaredOutputType,
})

/**
 * WorkflowNodeJobConfig
 */
export const zWorkflowNodeJobConfig = z.object({
  declared_outputs: z.array(zDeclaredOutputConfig).optional(),
  human_contacts: z.array(zAgentHumanContactConfig).optional(),
  metadata: zWorkflowNodeJobMetadata.optional(),
  mode: zWorkflowNodeJobMode.optional().default('tell_agent_what_to_do'),
  previous_node_output_refs: z.array(zWorkflowPreviousNodeOutputRef).optional(),
  schema_version: z.int().optional().default(1),
  workflow_prompt: z.string().optional().default(''),
})

/**
 * ButtonStyle
 *
 * Button styles for user actions.
 */
export const zButtonStyle = z.enum(['accent', 'default', 'ghost', 'primary'])

/**
 * UserActionConfig
 *
 * User action configuration.
 */
export const zUserActionConfig = z.object({
  button_style: zButtonStyle.optional().default('default'),
  id: z.string().max(20),
  title: z.string().max(100),
})

/**
 * FileInputConfig
 */
export const zFileInputConfig = z.object({
  allowed_file_extensions: z.array(z.string()).optional(),
  allowed_file_types: z.array(zFileType).optional(),
  allowed_file_upload_methods: z.array(zFileTransferMethod).optional(),
  output_variable_name: z.string(),
  type: z.literal('file').optional().default('file'),
})

/**
 * FileListInputConfig
 */
export const zFileListInputConfig = z.object({
  allowed_file_extensions: z.array(z.string()).optional(),
  allowed_file_types: z.array(zFileType).optional(),
  allowed_file_upload_methods: z.array(zFileTransferMethod).optional(),
  number_limits: z.int().gte(0).optional().default(0),
  output_variable_name: z.string(),
  type: z.literal('file-list').optional().default('file-list'),
})

/**
 * AgentKnowledgeModelConfig
 */
export const zAgentKnowledgeModelConfig = z.object({
  completion_params: z.record(z.string(), z.unknown()).optional(),
  mode: z.string().min(1).max(64),
  name: z.string().min(1).max(255),
  provider: z.string().min(1).max(255),
})

/**
 * AgentKnowledgeQueryMode
 */
export const zAgentKnowledgeQueryMode = z.enum(['generated_query', 'user_query'])

/**
 * AgentKnowledgeQueryConfig
 *
 * Per-set query policy for Agent v2 knowledge retrieval.
 *
 * Agent v2 stores knowledge as explicit ``knowledge.sets`` rather than the
 * legacy flat ``datasets`` / ``query_mode`` / ``query_config`` shape. Each
 * set owns its own query policy. Mode-dependent completeness, such as
 * requiring ``value`` for ``user_query``, is enforced by composer publish
 * validation so draft saves can persist partially configured knowledge sets.
 */
export const zAgentKnowledgeQueryConfig = z.object({
  mode: zAgentKnowledgeQueryMode,
  value: z.string().nullish(),
})

/**
 * AgentKnowledgeRerankingModelConfig
 */
export const zAgentKnowledgeRerankingModelConfig = z.object({
  model: z.string().min(1).max(255),
  provider: z.string().min(1).max(255),
})

/**
 * AgentKnowledgeWeightedScoreConfig
 */
export const zAgentKnowledgeWeightedScoreConfig = z.object({
  keyword_setting: z.record(z.string(), z.unknown()).nullish(),
  vector_setting: z.record(z.string(), z.unknown()).nullish(),
  weight_type: z.string().max(64).nullish(),
})

/**
 * AgentKnowledgeRetrievalConfig
 *
 * Per-set retrieval policy for Agent v2 knowledge retrieval.
 *
 * Retrieval settings now live on each knowledge set instead of one shared
 * flat config. Mode-dependent completeness, such as requiring ``top_k`` for
 * ``multiple`` or a model for ``single``, is enforced by composer publish
 * validation so draft saves can persist partially configured knowledge sets.
 */
export const zAgentKnowledgeRetrievalConfig = z.object({
  mode: z.enum(['multiple', 'single']),
  model: zAgentKnowledgeModelConfig.nullish(),
  reranking_enable: z.boolean().optional().default(true),
  reranking_mode: z.string().optional().default('reranking_model'),
  reranking_model: zAgentKnowledgeRerankingModelConfig.nullish(),
  score_threshold: z.number().gte(0).lte(1).nullish(),
  top_k: z.int().gte(1).nullish(),
  weights: zAgentKnowledgeWeightedScoreConfig.nullish(),
})

/**
 * AgentKnowledgeMetadataCondition
 */
export const zAgentKnowledgeMetadataCondition = z.object({
  comparison_operator: z.enum([
    '<',
    '=',
    '>',
    'after',
    'before',
    'contains',
    'empty',
    'end with',
    'in',
    'is',
    'is not',
    'not contains',
    'not empty',
    'not in',
    'start with',
    '≠',
    '≤',
    '≥',
  ]),
  name: z.string().min(1).max(255),
  value: z.union([z.string(), z.array(z.string()), z.number()]).nullish(),
})

/**
 * AgentKnowledgeMetadataConditions
 */
export const zAgentKnowledgeMetadataConditions = z.object({
  conditions: z.array(zAgentKnowledgeMetadataCondition).optional(),
  logical_operator: z.enum(['and', 'or']).optional().default('and'),
})

/**
 * AgentKnowledgeMetadataFilteringConfig
 *
 * Per-set metadata filtering policy.
 *
 * The Python attribute uses ``metadata_model_config`` for clarity because the
 * model belongs to metadata filtering specifically, while the external API and
 * generated schema keep the historical ``model_config`` field name via alias.
 * Mode-dependent completeness is enforced by composer publish validation so
 * draft saves can persist partially configured metadata filters.
 */
export const zAgentKnowledgeMetadataFilteringConfig = z.object({
  conditions: zAgentKnowledgeMetadataConditions.nullish(),
  mode: z.enum(['automatic', 'disabled', 'manual']).optional().default('disabled'),
  model_config: zAgentKnowledgeModelConfig.nullish(),
})

/**
 * AgentKnowledgeSetConfig
 *
 * One explicit knowledge set in Agent v2.
 *
 * ``knowledge.sets`` replaces the old flat knowledge config. Each set owns
 * its datasets plus query, retrieval, and metadata policies. An individual
 * set must contain at least one dataset id even though the overall knowledge
 * section may be empty, which is how callers express "no knowledge layer".
 */
export const zAgentKnowledgeSetConfig = z.object({
  datasets: z.array(zAgentKnowledgeDatasetConfig),
  description: z.string().nullish(),
  id: z.string().min(1).max(255),
  metadata_filtering: zAgentKnowledgeMetadataFilteringConfig.optional(),
  name: z.string().min(1).max(255),
  query: zAgentKnowledgeQueryConfig,
  retrieval: zAgentKnowledgeRetrievalConfig,
})

/**
 * AgentSoulKnowledgeConfig
 *
 * Top-level Agent v2 knowledge config.
 *
 * Agent v2 models knowledge as explicit sets instead of one flat
 * ``datasets`` / ``query_mode`` / ``query_config`` block. An empty ``sets``
 * list means no knowledge layer should be emitted at runtime, while set-name
 * uniqueness stays case-insensitive because runtime selection addresses sets
 * by name.
 */
export const zAgentSoulKnowledgeConfig = z.object({
  sets: z.array(zAgentKnowledgeSetConfig).optional(),
})

/**
 * AgentSoulConfig
 */
export const zAgentSoulConfig = z.object({
  app_features: zAgentSoulAppFeaturesConfig.optional(),
  app_variables: z.array(zAppVariableConfig).optional(),
  config_files: z.array(zAgentConfigFileRefConfig).optional(),
  config_note: z.string().optional().default(''),
  config_skills: z.array(zAgentConfigSkillRefConfig).optional(),
  env: zAgentSoulEnvConfig.optional(),
  files: zAgentSoulFilesConfig.optional(),
  human: zAgentSoulHumanConfig.optional(),
  knowledge: zAgentSoulKnowledgeConfig.optional(),
  memory: zAgentSoulMemoryConfig.optional(),
  misc_legacy: zAgentSoulAppFeaturesConfig.optional(),
  model: zAgentSoulModelConfig.nullish(),
  prompt: zAgentSoulPromptConfig.optional(),
  sandbox: zAgentSoulSandboxConfig.optional(),
  schema_version: z.int().optional().default(1),
  tools: zAgentSoulToolsConfig.optional(),
})

/**
 * AgentBuildDraftResponse
 */
export const zAgentBuildDraftResponse = z.object({
  agent_soul: zAgentSoulConfig,
  draft: zAgentConfigDraftSummaryResponse,
  variant: z.string(),
})

/**
 * ComposerSavePayload
 */
export const zComposerSavePayload = z.object({
  agent_soul: zAgentSoulConfig.nullish(),
  binding: zComposerBindingPayload.nullish(),
  client_revision_id: z.string().nullish(),
  description: z.string().nullish(),
  icon: z.string().max(255).nullish(),
  icon_background: z.string().max(255).nullish(),
  icon_type: zAgentIconType.nullish(),
  idempotency_key: z.string().nullish(),
  new_agent_name: z.string().min(1).max(255).nullish(),
  node_job: zWorkflowNodeJobConfig.nullish(),
  role: z.string().max(255).nullish(),
  save_strategy: zComposerSaveStrategy,
  soul_lock: zComposerSoulLockPayload.optional(),
  variant: zComposerVariant,
  version_note: z.string().nullish(),
})

/**
 * AgentAppComposerResponse
 */
export const zAgentAppComposerResponse = z.object({
  active_config_snapshot: zAgentConfigSnapshotSummaryResponse.nullish(),
  agent: zAgentComposerAgentResponse,
  agent_soul: zAgentSoulConfig,
  app_id: z.string().nullish(),
  backing_app_id: z.string().nullish(),
  chat_endpoint: z.string().nullish(),
  draft: zAgentConfigDraftSummaryResponse.nullish(),
  hidden_app_backed: z.boolean().optional().default(false),
  save_options: z.array(zComposerSaveStrategy),
  validation: zComposerValidationFindingsResponse.nullish(),
  variant: z.literal('agent_app'),
})

/**
 * AgentConfigSnapshotDetailResponse
 */
export const zAgentConfigSnapshotDetailResponse = z.object({
  agent_id: z.string().nullish(),
  config_snapshot: zAgentSoulConfig,
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  display_version: z.int().nullish(),
  id: z.string(),
  revisions: z.array(zAgentConfigRevisionResponse).optional(),
  snapshot_version: z.int().nullish(),
  summary: z.string().nullish(),
  version: z.int(),
  version_note: z.string().nullish(),
})

/**
 * ValueSourceType
 *
 * ValueSourceType records whether the value comes from a static setting
 * in form definiton, or a variable while the workflow is running.
 */
export const zValueSourceType = z.enum(['constant', 'variable'])

/**
 * StringSource
 *
 * Default configuration for form inputs.
 */
export const zStringSource = z.object({
  selector: z.array(z.string()).optional(),
  type: zValueSourceType,
  value: z.string().optional().default(''),
})

/**
 * ParagraphInputConfig
 *
 * Form input definition.
 */
export const zParagraphInputConfig = z.object({
  default: zStringSource.nullish(),
  output_variable_name: z.string(),
  type: z.literal('paragraph').optional().default('paragraph'),
})

/**
 * StringListSource
 */
export const zStringListSource = z.object({
  selector: z.array(z.string()).optional(),
  type: zValueSourceType,
  value: z.array(z.string()).optional(),
})

/**
 * SelectInputConfig
 */
export const zSelectInputConfig = z.object({
  option_source: zStringListSource,
  output_variable_name: z.string(),
  type: z.literal('select').optional().default('select'),
})

export const zFormInputConfig = z.discriminatedUnion('type', [
  zParagraphInputConfig.extend({ type: z.literal('paragraph') }),
  zSelectInputConfig.extend({ type: z.literal('select') }),
  zFileInputConfig.extend({ type: z.literal('file') }),
  zFileListInputConfig.extend({ type: z.literal('file-list') }),
])

/**
 * HumanInputFormDefinition
 */
export const zHumanInputFormDefinition = z.object({
  actions: z.array(zUserActionConfig).optional(),
  display_in_ui: z.boolean().optional().default(false),
  expiration_time: z.int(),
  form_content: z.string(),
  form_id: z.string(),
  form_token: z.string().nullish(),
  inputs: z.array(zFormInputConfig).optional(),
  node_id: z.string(),
  node_title: z.string(),
  resolved_default_values: z.record(z.string(), z.unknown()).optional(),
})

/**
 * HumanInputContent
 */
export const zHumanInputContent = z.object({
  form_definition: zHumanInputFormDefinition.nullish(),
  form_submission_data: zHumanInputFormSubmissionData.nullish(),
  submitted: z.boolean(),
  type: zExecutionContentType.optional().default('human_input'),
  workflow_run_id: z.string(),
})

/**
 * MessageDetailResponse
 */
export const zMessageDetailResponse = z.object({
  agent_thoughts: z.array(zAgentThought),
  annotation: zConversationAnnotation.nullish(),
  annotation_hit_history: zConversationAnnotationHitHistory.nullish(),
  answer: z.string(),
  answer_tokens: z.int(),
  conversation_id: z.string(),
  created_at: z.int().nullish(),
  error: z.string().nullish(),
  extra_contents: z.array(zHumanInputContent).optional(),
  feedbacks: z.array(zFeedback),
  from_account_id: z.string().nullish(),
  from_end_user_id: z.string().nullish(),
  from_source: z.string(),
  id: z.string(),
  inputs: z.record(z.string(), zJsonValue),
  message: zJsonValue,
  message_files: z.array(zMessageFile),
  message_tokens: z.int(),
  metadata: zJsonValue,
  parent_message_id: z.string().nullish(),
  provider_response_latency: z.number(),
  query: z.string(),
  status: z.string(),
  workflow_run_id: z.string().nullish(),
})

/**
 * MessageInfiniteScrollPaginationResponse
 */
export const zMessageInfiniteScrollPaginationResponse = z.object({
  data: z.array(zMessageDetailResponse),
  has_more: z.boolean(),
  limit: z.int(),
})

/**
 * AgentAppPartial
 */
export const zAgentAppPartialWritable = z.object({
  access_mode: z.string().nullish(),
  active_config_is_published: z.boolean().optional().default(false),
  app_id: z.string().nullish(),
  author_name: z.string().nullish(),
  backing_app_id: z.string().nullish(),
  bound_agent_id: z.string().nullish(),
  create_user_name: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  debug_conversation_id: z.string().nullish(),
  description: z.string().nullish(),
  has_draft_trigger: z.boolean().nullish(),
  hidden_app_backed: z.boolean().optional().default(false),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  id: z.string(),
  is_starred: z.boolean().optional().default(false),
  maintainer: z.string().nullish(),
  max_active_requests: z.int().nullish(),
  mode: z.string(),
  model_config: zModelConfigPartial.nullish(),
  name: z.string(),
  permission_keys: z.array(z.string()).optional(),
  published_reference_count: z.int().optional().default(0),
  published_references: z.array(zAgentAppPublishedReferenceResponse).optional(),
  reference_count: z.int().nullish(),
  role: z.string().nullish(),
  tags: z.array(zTag).optional(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
  use_icon_as_answer_icon: z.boolean().nullish(),
  workflow: zWorkflowPartial.nullish(),
})

/**
 * AgentAppPagination
 */
export const zAgentAppPaginationWritable = z.object({
  data: z.array(zAgentAppPartialWritable),
  has_more: z.boolean(),
  limit: z.int(),
  page: z.int(),
  total: z.int(),
})

/**
 * AppDetailSiteResponse
 */
export const zAppDetailSiteResponseWritable = z.object({
  access_token: z.string().nullish(),
  app_base_url: z.string().nullish(),
  chat_color_theme: z.string().nullish(),
  chat_color_theme_inverted: z.boolean().nullish(),
  code: z.string().nullish(),
  copyright: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  custom_disclaimer: z.string().nullish(),
  customize_domain: z.string().nullish(),
  customize_token_strategy: z.string().nullish(),
  default_language: z.string().nullish(),
  description: z.string().nullish(),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.union([z.string(), zIconType]).nullish(),
  input_placeholder: z.string().nullish(),
  privacy_policy: z.string().nullish(),
  prompt_public: z.boolean().nullish(),
  show_workflow_steps: z.boolean().nullish(),
  title: z.string().nullish(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
  use_icon_as_answer_icon: z.boolean().nullish(),
})

/**
 * AgentAppDetailWithSite
 */
export const zAgentAppDetailWithSiteWritable = z.object({
  access_mode: z.string().nullish(),
  active_config_is_published: z.boolean().optional().default(false),
  api_base_url: z.string().nullish(),
  app_id: z.string().nullish(),
  backing_app_id: z.string().nullish(),
  bound_agent_id: z.string().nullish(),
  created_at: z.int().nullish(),
  created_by: z.string().nullish(),
  debug_conversation_has_messages: z.boolean().optional().default(false),
  debug_conversation_id: z.string().nullish(),
  debug_conversation_message_count: z.int().optional().default(0),
  deleted_tools: z.array(zDeletedTool).optional(),
  description: z.string().nullish(),
  enable_api: z.boolean(),
  enable_site: z.boolean(),
  hidden_app_backed: z.boolean().optional().default(false),
  icon: z.string().nullish(),
  icon_background: z.string().nullish(),
  icon_type: z.string().nullish(),
  id: z.string(),
  maintainer: z.string().nullish(),
  max_active_requests: z.int().nullish(),
  mode: z.string(),
  model_config: zModelConfig.nullish(),
  name: z.string(),
  permission_keys: z.array(z.string()).optional(),
  role: z.string().nullish(),
  site: zAppDetailSiteResponseWritable.nullish(),
  tags: z.array(zTag).optional(),
  tracing: z.unknown().nullish(),
  updated_at: z.int().nullish(),
  updated_by: z.string().nullish(),
  use_icon_as_answer_icon: z.boolean().nullish(),
  workflow: zWorkflowPartial.nullish(),
})

export const zGetAgentQuery = z.object({
  creator_ids: z.array(z.string()).optional(),
  is_created_by_me: z.boolean().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  mode: z
    .enum([
      'advanced-chat',
      'agent',
      'agent-chat',
      'all',
      'channel',
      'chat',
      'completion',
      'workflow',
    ])
    .optional()
    .default('all'),
  name: z.string().optional(),
  page: z.int().gte(1).lte(99999).optional().default(1),
  sort_by: z
    .enum(['earliest_created', 'last_modified', 'recently_created'])
    .optional()
    .default('last_modified'),
  tag_ids: z.array(z.string()).optional(),
})

/**
 * Agent app list
 */
export const zGetAgentResponse = zAgentAppPagination

export const zPostAgentBody = zAgentAppCreatePayload

/**
 * Agent app created successfully
 */
export const zPostAgentResponse = zAgentAppDetailWithSite

export const zGetAgentInviteOptionsQuery = z.object({
  app_id: z.string().optional(),
  keyword: z.string().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  page: z.int().gte(1).optional().default(1),
})

/**
 * Agent invite options
 */
export const zGetAgentInviteOptionsResponse = zAgentInviteOptionsResponse

export const zDeleteAgentByAgentIdPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent app deleted successfully
 */
export const zDeleteAgentByAgentIdResponse = z.void()

export const zGetAgentByAgentIdPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent app detail
 */
export const zGetAgentByAgentIdResponse = zAgentAppDetailWithSite

export const zPutAgentByAgentIdBody = zAgentAppUpdatePayload

export const zPutAgentByAgentIdPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent app updated successfully
 */
export const zPutAgentByAgentIdResponse = zAgentAppDetailWithSite

export const zGetAgentByAgentIdApiAccessPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent service API access
 */
export const zGetAgentByAgentIdApiAccessResponse = zAgentApiAccessResponse

export const zPostAgentByAgentIdApiEnableBody = zAgentApiStatusPayload

export const zPostAgentByAgentIdApiEnablePath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent service API status updated
 */
export const zPostAgentByAgentIdApiEnableResponse = zAgentApiAccessResponse

export const zGetAgentByAgentIdApiKeysPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent service API keys
 */
export const zGetAgentByAgentIdApiKeysResponse = zApiKeyList

export const zPostAgentByAgentIdApiKeysPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent service API key created
 */
export const zPostAgentByAgentIdApiKeysResponse = zApiKeyItem

export const zDeleteAgentByAgentIdApiKeysByApiKeyIdPath = z.object({
  agent_id: z.uuid(),
  api_key_id: z.uuid(),
})

/**
 * Agent service API key deleted
 */
export const zDeleteAgentByAgentIdApiKeysByApiKeyIdResponse = z.void()

export const zPostAgentByAgentIdAudioToTextBody = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional().default('draft'),
  file: z.custom<Blob | File>(),
})

export const zPostAgentByAgentIdAudioToTextPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Audio transcription successful
 */
export const zPostAgentByAgentIdAudioToTextResponse = zAudioTranscriptResponse

export const zPostAgentByAgentIdBuildChatFinalizePath = z.object({
  agent_id: z.uuid(),
})

/**
 * Success
 */
export const zPostAgentByAgentIdBuildChatFinalizeResponse = zSimpleResultResponse

export const zDeleteAgentByAgentIdBuildDraftPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent build draft discarded
 */
export const zDeleteAgentByAgentIdBuildDraftResponse = zAgentSimpleResultResponse

export const zGetAgentByAgentIdBuildDraftPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent build draft
 */
export const zGetAgentByAgentIdBuildDraftResponse = zAgentBuildDraftResponse

export const zPutAgentByAgentIdBuildDraftBody = zComposerSavePayload

export const zPutAgentByAgentIdBuildDraftPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent build draft saved
 */
export const zPutAgentByAgentIdBuildDraftResponse = zAgentBuildDraftResponse

export const zPostAgentByAgentIdBuildDraftApplyPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent build draft applied
 */
export const zPostAgentByAgentIdBuildDraftApplyResponse = zAgentBuildDraftApplyResponse

export const zPostAgentByAgentIdBuildDraftCheckoutBody = zAgentBuildDraftCheckoutPayload

export const zPostAgentByAgentIdBuildDraftCheckoutPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent build draft checked out
 */
export const zPostAgentByAgentIdBuildDraftCheckoutResponse = zAgentBuildDraftResponse

export const zGetAgentByAgentIdChatMessagesPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdChatMessagesQuery = z.object({
  conversation_id: z.string(),
  first_id: z.string().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
})

/**
 * Success
 */
export const zGetAgentByAgentIdChatMessagesResponse = zMessageInfiniteScrollPaginationResponse

export const zGetAgentByAgentIdChatMessagesByMessageIdSuggestedQuestionsPath = z.object({
  agent_id: z.uuid(),
  message_id: z.uuid(),
})

/**
 * Suggested questions retrieved successfully
 */
export const zGetAgentByAgentIdChatMessagesByMessageIdSuggestedQuestionsResponse =
  zSuggestedQuestionsResponse

export const zPostAgentByAgentIdChatMessagesByTaskIdStopPath = z.object({
  agent_id: z.uuid(),
  task_id: z.string(),
})

/**
 * Task stopped successfully
 */
export const zPostAgentByAgentIdChatMessagesByTaskIdStopResponse = zSimpleResultResponse

export const zGetAgentByAgentIdComposerPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent app composer state
 */
export const zGetAgentByAgentIdComposerResponse = zAgentAppComposerResponse

export const zPutAgentByAgentIdComposerBody = zComposerSavePayload

export const zPutAgentByAgentIdComposerPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent app composer saved
 */
export const zPutAgentByAgentIdComposerResponse = zAgentAppComposerResponse

export const zGetAgentByAgentIdComposerCandidatesPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent app composer candidates
 */
export const zGetAgentByAgentIdComposerCandidatesResponse = zAgentComposerCandidatesResponse

export const zPostAgentByAgentIdComposerValidateBody = zComposerSavePayload

export const zPostAgentByAgentIdComposerValidatePath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent app composer validation result
 */
export const zPostAgentByAgentIdComposerValidateResponse = zAgentComposerValidateResponse

export const zGetAgentByAgentIdConfigFilesPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdConfigFilesQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  version_id: z.string().optional(),
})

/**
 * Config files
 */
export const zGetAgentByAgentIdConfigFilesResponse = zAgentConfigFileListResponse

export const zPostAgentByAgentIdConfigFilesBody = zAgentConfigFileUploadPayload

export const zPostAgentByAgentIdConfigFilesPath = z.object({
  agent_id: z.uuid(),
})

export const zPostAgentByAgentIdConfigFilesQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  version_id: z.string().optional(),
})

/**
 * Uploaded config file
 */
export const zPostAgentByAgentIdConfigFilesResponse = zAgentConfigFileUploadResponse

export const zDeleteAgentByAgentIdConfigFilesByNamePath = z.object({
  agent_id: z.uuid(),
  name: z.string(),
})

export const zDeleteAgentByAgentIdConfigFilesByNameQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  version_id: z.string().optional(),
})

/**
 * Config file deleted
 */
export const zDeleteAgentByAgentIdConfigFilesByNameResponse = zAgentConfigDeleteResponse

export const zGetAgentByAgentIdConfigFilesByNameDownloadPath = z.object({
  agent_id: z.uuid(),
  name: z.string(),
})

export const zGetAgentByAgentIdConfigFilesByNameDownloadQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  version_id: z.string().optional(),
})

/**
 * Config file download URL
 */
export const zGetAgentByAgentIdConfigFilesByNameDownloadResponse = zAgentConfigDownloadResponse

export const zGetAgentByAgentIdConfigFilesByNamePreviewPath = z.object({
  agent_id: z.uuid(),
  name: z.string(),
})

export const zGetAgentByAgentIdConfigFilesByNamePreviewQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  version_id: z.string().optional(),
})

/**
 * Preview
 */
export const zGetAgentByAgentIdConfigFilesByNamePreviewResponse = zAgentConfigFilePreviewResponse

export const zGetAgentByAgentIdConfigManifestPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdConfigManifestQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  version_id: z.string().optional(),
})

/**
 * Agent config manifest
 */
export const zGetAgentByAgentIdConfigManifestResponse = zAgentConfigManifestResponse

export const zGetAgentByAgentIdConfigSkillsPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdConfigSkillsQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  version_id: z.string().optional(),
})

/**
 * Config skills
 */
export const zGetAgentByAgentIdConfigSkillsResponse = zAgentConfigSkillListResponse

export const zPostAgentByAgentIdConfigSkillsUploadBody = z.object({
  file: z.custom<Blob | File>(),
})

export const zPostAgentByAgentIdConfigSkillsUploadPath = z.object({
  agent_id: z.uuid(),
})

export const zPostAgentByAgentIdConfigSkillsUploadQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  version_id: z.string().optional(),
})

/**
 * Uploaded config skill
 */
export const zPostAgentByAgentIdConfigSkillsUploadResponse = zAgentConfigSkillUploadResponse

export const zDeleteAgentByAgentIdConfigSkillsByNamePath = z.object({
  agent_id: z.uuid(),
  name: z.string(),
})

export const zDeleteAgentByAgentIdConfigSkillsByNameQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  version_id: z.string().optional(),
})

/**
 * Config skill deleted
 */
export const zDeleteAgentByAgentIdConfigSkillsByNameResponse = zAgentConfigDeleteResponse

export const zGetAgentByAgentIdConfigSkillsByNameDownloadPath = z.object({
  agent_id: z.uuid(),
  name: z.string(),
})

export const zGetAgentByAgentIdConfigSkillsByNameDownloadQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  version_id: z.string().optional(),
})

/**
 * Config skill download URL
 */
export const zGetAgentByAgentIdConfigSkillsByNameDownloadResponse = zAgentConfigDownloadResponse

export const zGetAgentByAgentIdConfigSkillsByNameFilesContentPath = z.object({
  agent_id: z.uuid(),
  name: z.string(),
})

/**
 * Success
 */
export const zGetAgentByAgentIdConfigSkillsByNameFilesContentResponse = z.record(
  z.string(),
  z.unknown(),
)

export const zGetAgentByAgentIdConfigSkillsByNameFilesDownloadPath = z.object({
  agent_id: z.uuid(),
  name: z.string(),
})

export const zGetAgentByAgentIdConfigSkillsByNameFilesDownloadQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  path: z.string(),
  version_id: z.string().optional(),
})

/**
 * Config skill file download URL
 */
export const zGetAgentByAgentIdConfigSkillsByNameFilesDownloadResponse =
  zAgentConfigDownloadResponse

export const zGetAgentByAgentIdConfigSkillsByNameFilesPreviewPath = z.object({
  agent_id: z.uuid(),
  name: z.string(),
})

export const zGetAgentByAgentIdConfigSkillsByNameFilesPreviewQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  path: z.string(),
  version_id: z.string().optional(),
})

/**
 * Config skill file preview
 */
export const zGetAgentByAgentIdConfigSkillsByNameFilesPreviewResponse =
  zAgentConfigSkillFilePreviewResponse

export const zGetAgentByAgentIdConfigSkillsByNameInspectPath = z.object({
  agent_id: z.uuid(),
  name: z.string(),
})

export const zGetAgentByAgentIdConfigSkillsByNameInspectQuery = z.object({
  draft_type: z.enum(['debug_build', 'draft']).optional(),
  version_id: z.string().optional(),
})

/**
 * Config skill inspect view
 */
export const zGetAgentByAgentIdConfigSkillsByNameInspectResponse = zAgentConfigSkillInspectResponse

export const zPostAgentByAgentIdCopyBody = zAgentAppCopyPayload

export const zPostAgentByAgentIdCopyPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent app copied successfully
 */
export const zPostAgentByAgentIdCopyResponse = zAgentAppDetailWithSite

export const zPostAgentByAgentIdDebugConversationRefreshPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent debug conversation refreshed
 */
export const zPostAgentByAgentIdDebugConversationRefreshResponse =
  zAgentDebugConversationRefreshResponse

export const zGetAgentByAgentIdDriveFilesPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdDriveFilesQuery = z.object({
  prefix: z.string().optional().default(''),
})

/**
 * Drive entries
 */
export const zGetAgentByAgentIdDriveFilesResponse = zAgentDriveListResponse

export const zGetAgentByAgentIdDriveFilesDownloadPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdDriveFilesDownloadQuery = z.object({
  key: z.string().min(1),
})

/**
 * Signed URL
 */
export const zGetAgentByAgentIdDriveFilesDownloadResponse = zAgentDriveDownloadResponse

export const zGetAgentByAgentIdDriveFilesPreviewPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdDriveFilesPreviewQuery = z.object({
  key: z.string().min(1),
})

/**
 * Preview
 */
export const zGetAgentByAgentIdDriveFilesPreviewResponse = zAgentDrivePreviewResponse

export const zGetAgentByAgentIdDriveSkillsPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Drive skills
 */
export const zGetAgentByAgentIdDriveSkillsResponse = zAgentDriveSkillListResponse

export const zGetAgentByAgentIdDriveSkillsBySkillPathInspectPath = z.object({
  agent_id: z.uuid(),
  skill_path: z.string(),
})

/**
 * Drive skill inspect view
 */
export const zGetAgentByAgentIdDriveSkillsBySkillPathInspectResponse =
  zAgentDriveSkillInspectResponse

export const zPostAgentByAgentIdFeaturesBody = zAgentAppFeaturesPayload

export const zPostAgentByAgentIdFeaturesPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Features updated successfully
 */
export const zPostAgentByAgentIdFeaturesResponse = zSimpleResultResponse

export const zPostAgentByAgentIdFeedbacksBody = zMessageFeedbackPayload

export const zPostAgentByAgentIdFeedbacksPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Feedback updated successfully
 */
export const zPostAgentByAgentIdFeedbacksResponse = zSimpleResultResponse

export const zDeleteAgentByAgentIdFilesPath = z.object({
  agent_id: z.uuid(),
})

export const zDeleteAgentByAgentIdFilesQuery = z.object({
  key: z.string().min(1),
})

/**
 * File removed
 */
export const zDeleteAgentByAgentIdFilesResponse = zAgentDriveDeleteResponse

export const zPostAgentByAgentIdFilesBody = zAgentDriveFilePayload

export const zPostAgentByAgentIdFilesPath = z.object({
  agent_id: z.uuid(),
})

/**
 * File committed into the agent drive
 */
export const zPostAgentByAgentIdFilesResponse = zAgentDriveFileCommitResponse

export const zGetAgentByAgentIdLogSourcesPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent log sources
 */
export const zGetAgentByAgentIdLogSourcesResponse = zAgentLogSourceListResponse

export const zGetAgentByAgentIdLogsPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdLogsQuery = z.object({
  end: z.string().optional(),
  keyword: z.string().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  page: z.int().gte(1).optional().default(1),
  sort_by: z.string().optional().default('updated_at'),
  sort_order: z.string().optional().default('desc'),
  source: z.string().optional(),
  sources: z.array(z.string()).optional(),
  start: z.string().optional(),
  status: z.string().optional(),
  statuses: z.array(z.string()).optional(),
})

/**
 * Agent logs
 */
export const zGetAgentByAgentIdLogsResponse = zAgentLogListResponse

export const zGetAgentByAgentIdLogsByConversationIdMessagesPath = z.object({
  agent_id: z.uuid(),
  conversation_id: z.uuid(),
})

export const zGetAgentByAgentIdLogsByConversationIdMessagesQuery = z.object({
  end: z.string().optional(),
  keyword: z.string().optional(),
  limit: z.int().gte(1).lte(100).optional().default(20),
  page: z.int().gte(1).optional().default(1),
  sort_by: z.string().optional().default('updated_at'),
  sort_order: z.string().optional().default('desc'),
  source: z.string().optional(),
  sources: z.array(z.string()).optional(),
  start: z.string().optional(),
  status: z.string().optional(),
  statuses: z.array(z.string()).optional(),
})

/**
 * Agent log messages
 */
export const zGetAgentByAgentIdLogsByConversationIdMessagesResponse = zAgentLogMessageListResponse

export const zGetAgentByAgentIdMessagesByMessageIdPath = z.object({
  agent_id: z.uuid(),
  message_id: z.uuid(),
})

/**
 * Message retrieved successfully
 */
export const zGetAgentByAgentIdMessagesByMessageIdResponse = zMessageDetailResponse

export const zPostAgentByAgentIdPublishBody = zAgentPublishPayload

export const zPostAgentByAgentIdPublishPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent draft published
 */
export const zPostAgentByAgentIdPublishResponse = zAgentPublishResponse

export const zGetAgentByAgentIdReferencingWorkflowsPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Referencing workflows listed successfully
 */
export const zGetAgentByAgentIdReferencingWorkflowsResponse = zAgentReferencingWorkflowsResponse

export const zGetAgentByAgentIdSandboxPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdSandboxQuery = z.object({
  conversation_id: z.string().min(1),
})

/**
 * Sandbox information returned
 */
export const zGetAgentByAgentIdSandboxResponse = zSandboxInfoResponse

export const zGetAgentByAgentIdSandboxFilesPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdSandboxFilesQuery = z.object({
  conversation_id: z.string().min(1),
  path: z.string().optional().default('.'),
})

/**
 * Listing returned
 */
export const zGetAgentByAgentIdSandboxFilesResponse = zSandboxListResponse

export const zGetAgentByAgentIdSandboxFilesReadPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdSandboxFilesReadQuery = z.object({
  conversation_id: z.string().min(1),
  path: z.string().min(1),
})

/**
 * Preview returned
 */
export const zGetAgentByAgentIdSandboxFilesReadResponse = zSandboxReadResponse

export const zPostAgentByAgentIdSandboxFilesUploadBody = zAgentSandboxUploadPayload

export const zPostAgentByAgentIdSandboxFilesUploadPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Uploaded
 */
export const zPostAgentByAgentIdSandboxFilesUploadResponse = zSandboxUploadResponse

export const zPostAgentByAgentIdSkillsUploadBody = z.object({
  file: z.custom<Blob | File>(),
})

export const zPostAgentByAgentIdSkillsUploadPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Skill uploaded into drive
 */
export const zPostAgentByAgentIdSkillsUploadResponse = zAgentSkillUploadResponse

export const zDeleteAgentByAgentIdSkillsBySlugPath = z.object({
  agent_id: z.uuid(),
  slug: z.string(),
})

/**
 * Skill removed
 */
export const zDeleteAgentByAgentIdSkillsBySlugResponse = zAgentDriveDeleteResponse

export const zPostAgentByAgentIdSkillsBySlugInferToolsPath = z.object({
  agent_id: z.uuid(),
  slug: z.string(),
})

/**
 * Inference result (draft suggestions, nothing persisted)
 */
export const zPostAgentByAgentIdSkillsBySlugInferToolsResponse = zSkillToolInferenceResult

export const zGetAgentByAgentIdStatisticsSummaryPath = z.object({
  agent_id: z.uuid(),
})

export const zGetAgentByAgentIdStatisticsSummaryQuery = z.object({
  end: z.string().optional(),
  source: z.string().optional(),
  start: z.string().optional(),
})

/**
 * Agent monitoring summary and chart data
 */
export const zGetAgentByAgentIdStatisticsSummaryResponse = zAgentStatisticSummaryEnvelopeResponse

export const zGetAgentByAgentIdVersionsPath = z.object({
  agent_id: z.uuid(),
})

/**
 * Agent versions
 */
export const zGetAgentByAgentIdVersionsResponse = zAgentConfigSnapshotListResponse

export const zGetAgentByAgentIdVersionsByVersionIdPath = z.object({
  agent_id: z.uuid(),
  version_id: z.uuid(),
})

/**
 * Agent version detail
 */
export const zGetAgentByAgentIdVersionsByVersionIdResponse = zAgentConfigSnapshotDetailResponse

export const zPostAgentByAgentIdVersionsByVersionIdRestorePath = z.object({
  agent_id: z.uuid(),
  version_id: z.uuid(),
})

/**
 * Agent version restored
 */
export const zPostAgentByAgentIdVersionsByVersionIdRestoreResponse =
  zAgentConfigSnapshotRestoreResponse