feat: 数据处理向导配置体系扩展

新增结构化与非结构化处理选项类型，TaskSetupStep 增加预处理、切分方法、数据集划分等配置 UI，previewModel 实现语义切分与受保护区间算法，CreateView 接入配置状态与草稿持久化并替换为 AppConfirmDialog，回归脚本扩充配置与弹窗断言。
2026-07-11 14:49:10 +08:00
parent 9e16f6358d
commit ddf47eb8fe
5 changed files with 1941 additions and 66 deletions
--- a/frontend/src/views/data-process/create/TaskSetupStep.vue
+++ b/frontend/src/views/data-process/create/TaskSetupStep.vue
@@ -1,7 +1,18 @@
 <script setup lang="ts">
 import { computed, ref, watch } from 'vue'
 import type { FormInstance, FormRules, UploadFile } from 'element-plus'
-import type { ExternalDataSource, ProcessType } from './types'
+import type {
+  ChunkMethod,
+  DatasetSplitOptions,
+  ExternalDataSource,
+  GenerationContextScope,
+  PreprocessOption,
+  ProcessType,
+  QuestionGenerationType,
+  StructuredProcessOptions,
+  UnstructuredPreprocessOption,
+  UnstructuredProcessOptions,
+} from './types'

 const props = defineProps<{
  name: string
@@ -11,6 +22,8 @@ const props = defineProps<{
  externalSource: ExternalDataSource
  externalPulling: boolean
  externalConnected: boolean
+  structuredOptions: StructuredProcessOptions
+  unstructuredOptions: UnstructuredProcessOptions
 }>()

 const emit = defineEmits<{
@@ -18,6 +31,8 @@ const emit = defineEmits<{
  'update:description': [value: string]
  'update:processType': [value: ProcessType]
  'update:externalSource': [value: ExternalDataSource]
+  'update:structuredOptions': [value: StructuredProcessOptions]
+  'update:unstructuredOptions': [value: UnstructuredProcessOptions]
  'file-change': [file: UploadFile]
  'remove-file': [uid: string | number]
  'use-sample': []
@@ -38,16 +53,169 @@ const AUTH_MODES = [
  { value: 'token', label: 'Token' },
 ]

+const PREPROCESS_OPTIONS: Array<{
+  value: PreprocessOption
+  label: string
+  description: string
+}> = [
+  { value: 'clean_invalid', label: '清理无效数据', description: '处理空行、空列和残缺行' },
+  { value: 'detect_structure', label: '识别表格结构', description: '识别表头、多级表头和合并单元格' },
+  { value: 'deduplicate', label: '重复数据去重', description: '删除完全重复或关键字段重复的数据' },
+  { value: 'normalize_format', label: '数据格式标准化', description: '统一日期、数字、单位和枚举值格式' },
+  { value: 'filter_anomaly', label: '异常数据过滤', description: '过滤乱码、无效内容和异常记录' },
+  { value: 'desensitize', label: '敏感信息脱敏', description: '处理姓名、手机号、邮箱等敏感信息' },
+]
+
+const UNSTRUCTURED_PREPROCESS_OPTIONS: Array<{
+  value: UnstructuredPreprocessOption
+  label: string
+  description: string
+}> = [
+  { value: 'clean_invalid_content', label: '清理无效内容', description: '清除空段、乱码、页眉页脚和多余空白' },
+  { value: 'detect_document_structure', label: '识别文档结构', description: '识别标题、章节、段落及特殊内容块' },
+  { value: 'merge_short_content', label: '合并过短内容', description: '将信息不完整的过短段落并入上下文' },
+  { value: 'filter_low_quality', label: '过滤低质量内容', description: '过滤广告、导航、无意义重复及信息过少内容' },
+  { value: 'deduplicate_content', label: '重复内容去重', description: '识别完全重复或高度相似的段落' },
+  { value: 'desensitize', label: '敏感信息脱敏', description: '处理姓名、手机号、邮箱和证件号等信息' },
+  { value: 'preserve_context', label: '保留上下文信息', description: '为切片保留所属文档、章节和标题信息' },
+]
+
+const CHUNK_METHODS: Array<{ value: ChunkMethod; label: string }> = [
+  { value: 'semantic', label: '自动语义切分' },
+  { value: 'heading', label: '按标题和段落' },
+  { value: 'fixed', label: '按固定长度' },
+  { value: 'custom', label: '自定义分隔符' },
+]
+
+const CONTEXT_SCOPES: Array<{ value: GenerationContextScope; label: string }> = [
+  { value: 'current', label: '当前切片' },
+  { value: 'adjacent', label: '相邻切片' },
+  { value: 'section', label: '当前章节' },
+]
+
+const GENERATION_TYPES: Array<{ value: QuestionGenerationType; label: string }> = [
+  { value: 'factual', label: '事实问答' },
+  { value: 'concept', label: '概念解释' },
+  { value: 'procedure', label: '操作步骤' },
+  { value: 'reasoning', label: '原因分析' },
+  { value: 'comprehensive', label: '综合问答' },
+]
+
 function updateExternalField<K extends keyof ExternalDataSource>(field: K, value: ExternalDataSource[K]) {
  emit('update:externalSource', { ...props.externalSource, [field]: value })
 }

+function updateStructuredField<K extends keyof StructuredProcessOptions>(
+  field: K,
+  value: StructuredProcessOptions[K],
+) {
+  emit('update:structuredOptions', { ...props.structuredOptions, [field]: value })
+}
+
+function updatePreprocessOptions(value: Array<string | number | boolean>) {
+  const allowedValues = new Set(PREPROCESS_OPTIONS.map((option) => option.value))
+  const preprocessOptions = value.filter(
+    (option): option is PreprocessOption => typeof option === 'string' && allowedValues.has(option as PreprocessOption),
+  )
+  updateStructuredField('preprocessOptions', preprocessOptions)
+}
+
+function updateSemanticEnrichment(value: string | number | boolean) {
+  updateStructuredField('semanticEnrichment', Boolean(value))
+}
+
+function updateDatasetSplit(field: keyof DatasetSplitOptions, value: number | undefined) {
+  updateStructuredField('datasetSplit', {
+    ...props.structuredOptions.datasetSplit,
+    [field]: Math.min(100, Math.max(0, Number(value) || 0)),
+  })
+}
+
+function updateUnstructuredField<K extends keyof UnstructuredProcessOptions>(
+  field: K,
+  value: UnstructuredProcessOptions[K],
+) {
+  emit('update:unstructuredOptions', { ...props.unstructuredOptions, [field]: value })
+}
+
+function updateUnstructuredPreprocessOptions(value: Array<string | number | boolean>) {
+  const allowedValues = new Set(UNSTRUCTURED_PREPROCESS_OPTIONS.map((option) => option.value))
+  const preprocessOptions = value.filter(
+    (option): option is UnstructuredPreprocessOption => (
+      typeof option === 'string' && allowedValues.has(option as UnstructuredPreprocessOption)
+    ),
+  )
+  updateUnstructuredField('preprocessOptions', preprocessOptions)
+}
+
+function updateGenerationTypes(value: Array<string | number | boolean>) {
+  const allowedValues = new Set(GENERATION_TYPES.map((option) => option.value))
+  const generationTypes = value.filter(
+    (option): option is QuestionGenerationType => (
+      typeof option === 'string' && allowedValues.has(option as QuestionGenerationType)
+    ),
+  )
+  updateUnstructuredField('generationTypes', generationTypes)
+}
+
+const UNSTRUCTURED_NUMBER_LIMITS = {
+  chunkSize: { min: 200, max: 2000 },
+  chunkOverlap: { min: 0, max: 500 },
+  minChunkSize: { min: 20, max: 500 },
+  qaPairsPerChunk: { min: 1, max: 3 },
+} as const
+
+type UnstructuredNumberField = keyof typeof UNSTRUCTURED_NUMBER_LIMITS
+
+function updateUnstructuredNumber(field: UnstructuredNumberField, value: number | undefined) {
+  const limits = UNSTRUCTURED_NUMBER_LIMITS[field]
+  const parsedValue = Number(value)
+  const nextValue = Number.isFinite(parsedValue) ? parsedValue : limits.min
+  updateUnstructuredField(field, Math.min(limits.max, Math.max(limits.min, nextValue)))
+}
+
+function updateUnstructuredDatasetSplit(field: keyof DatasetSplitOptions, value: number | undefined) {
+  updateUnstructuredField('datasetSplit', {
+    ...props.unstructuredOptions.datasetSplit,
+    [field]: Math.min(100, Math.max(0, Number(value) || 0)),
+  })
+}
+
 const formRef = ref<FormInstance>()
 const formModel = computed(() => ({
  name: props.name,
  processType: props.processType,
 }))

+const splitTotal = computed(() => {
+  const { train, validation, test } = props.structuredOptions.datasetSplit
+  return train + validation + test
+})
+
+const unstructuredSplitTotal = computed(() => {
+  const { train, validation, test } = props.unstructuredOptions.datasetSplit
+  return train + validation + test
+})
+
+const chunkValidationMessage = computed(() => {
+  if (props.unstructuredOptions.chunkOverlap >= props.unstructuredOptions.chunkSize) {
+    return '重叠长度必须小于切片长度'
+  }
+  if (props.unstructuredOptions.minChunkSize > props.unstructuredOptions.chunkSize) {
+    return '最小切片长度不能大于切片长度'
+  }
+  if (
+    props.unstructuredOptions.chunkOverlap + props.unstructuredOptions.minChunkSize
+    > props.unstructuredOptions.chunkSize
+  ) {
+    return '重叠长度与最小切片长度之和不能大于切片长度'
+  }
+  if (props.unstructuredOptions.chunkMethod === 'custom' && !props.unstructuredOptions.customDelimiter.trim()) {
+    return '请输入自定义分隔符'
+  }
+  return ''
+})
+
 const rules: FormRules = {
  name: [
    { required: true, message: '请输入任务名称', trigger: 'blur' },
@@ -88,6 +256,12 @@ async function validate() {
  if (!formRef.value) return false
  try {
    await formRef.value.validate()
+    if (props.processType === 'structured' && splitTotal.value !== 100) return false
+    if (props.processType === 'unstructured') {
+      if (unstructuredSplitTotal.value !== 100) return false
+      if (chunkValidationMessage.value) return false
+      if (props.unstructuredOptions.generationTypes.length === 0) return false
+    }
    return true
  } catch {
    return false
@@ -178,6 +352,461 @@ defineExpose({ validate })
        </el-form-item>
      </div>

+      <template v-if="processType === 'structured'">
+        <div class="form-section structured-options-section">
+          <div class="section-title-row">
+            <div>
+              <h3>预处理选项</h3>
+              <p>选择在生成问答对之前需要执行的数据处理方式</p>
+            </div>
+          </div>
+          <el-checkbox-group
+            :model-value="structuredOptions.preprocessOptions"
+            class="preprocess-option-grid"
+            @update:model-value="updatePreprocessOptions"
+          >
+            <el-checkbox
+              v-for="option in PREPROCESS_OPTIONS"
+              :key="option.value"
+              :value="option.value"
+              class="preprocess-option"
+            >
+              <span class="preprocess-option-copy">
+                <strong>{{ option.label }}</strong>
+                <small>{{ option.description }}</small>
+              </span>
+            </el-checkbox>
+          </el-checkbox-group>
+        </div>
+
+        <div class="form-section generation-options-section">
+          <div class="section-title-row">
+            <div>
+              <h3>生成选项</h3>
+              <p>配置每条结构化记录生成问答对的方式和数量</p>
+            </div>
+          </div>
+          <div class="generation-option-list">
+            <div class="generation-option-row">
+              <div class="generation-option-copy">
+                <strong>语义丰富表达</strong>
+                <small>使用大模型将问答表述得更自然、柔和</small>
+              </div>
+              <el-switch
+                :model-value="structuredOptions.semanticEnrichment"
+                inline-prompt
+                active-text="开"
+                inactive-text="关"
+                @update:model-value="updateSemanticEnrichment"
+              />
+            </div>
+            <div class="generation-option-row">
+              <div class="generation-option-copy">
+                <strong>每行生成数量</strong>
+                <small>每行结构化数据生成的问答对数量</small>
+              </div>
+              <el-input-number
+                :model-value="structuredOptions.qaPairsPerRow"
+                :min="1"
+                :max="5"
+                :step="1"
+                controls-position="right"
+                @update:model-value="updateStructuredField('qaPairsPerRow', Number($event) || 1)"
+              />
+            </div>
+            <div class="generation-option-row dataset-split-row">
+              <div class="generation-option-copy">
+                <strong>数据集划分</strong>
+                <small>按比例将生成后的问答对随机划分为训练集、验证集和测试集</small>
+              </div>
+              <div class="dataset-split-config">
+                <div class="dataset-split-grid">
+                  <label class="dataset-split-field">
+                    <span>训练集</span>
+                    <span class="dataset-split-input">
+                      <el-input-number
+                        :model-value="structuredOptions.datasetSplit.train"
+                        :min="0"
+                        :max="100"
+                        :step="1"
+                        :precision="0"
+                        controls-position="right"
+                        aria-label="训练集比例"
+                        @update:model-value="updateDatasetSplit('train', $event)"
+                      />
+                      <span>%</span>
+                    </span>
+                  </label>
+                  <label class="dataset-split-field">
+                    <span>验证集</span>
+                    <span class="dataset-split-input">
+                      <el-input-number
+                        :model-value="structuredOptions.datasetSplit.validation"
+                        :min="0"
+                        :max="100"
+                        :step="1"
+                        :precision="0"
+                        controls-position="right"
+                        aria-label="验证集比例"
+                        @update:model-value="updateDatasetSplit('validation', $event)"
+                      />
+                      <span>%</span>
+                    </span>
+                  </label>
+                  <label class="dataset-split-field">
+                    <span>测试集</span>
+                    <span class="dataset-split-input">
+                      <el-input-number
+                        :model-value="structuredOptions.datasetSplit.test"
+                        :min="0"
+                        :max="100"
+                        :step="1"
+                        :precision="0"
+                        controls-position="right"
+                        aria-label="测试集比例"
+                        @update:model-value="updateDatasetSplit('test', $event)"
+                      />
+                      <span>%</span>
+                    </span>
+                  </label>
+                </div>
+                <div class="dataset-split-summary" :class="{ 'is-invalid': splitTotal !== 100 }">
+                  <span>总计 {{ splitTotal }}%</span>
+                  <span v-if="splitTotal !== 100" role="alert">训练集、验证集和测试集比例总和必须为 100%</span>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </template>
+
+      <template v-if="processType === 'unstructured'">
+        <div class="form-section unstructured-options-section">
+          <div class="section-title-row">
+            <div>
+              <h3>预处理选项</h3>
+              <p>先清理和补全文档语义，再进入切分和问答生成</p>
+            </div>
+          </div>
+          <el-checkbox-group
+            :model-value="unstructuredOptions.preprocessOptions"
+            class="preprocess-option-grid"
+            @update:model-value="updateUnstructuredPreprocessOptions"
+          >
+            <el-checkbox
+              v-for="option in UNSTRUCTURED_PREPROCESS_OPTIONS"
+              :key="option.value"
+              :value="option.value"
+              class="preprocess-option"
+            >
+              <span class="preprocess-option-copy">
+                <strong>{{ option.label }}</strong>
+                <small>{{ option.description }}</small>
+              </span>
+            </el-checkbox>
+          </el-checkbox-group>
+        </div>
+
+        <div class="form-section chunk-options-section">
+          <div class="section-title-row">
+            <div>
+              <h3>切分选项</h3>
+              <p>以语义完整为优先，将长文档拆成可独立生成问答的内容块</p>
+            </div>
+          </div>
+
+          <div class="chunk-settings-grid">
+            <label class="config-field">
+              <span class="config-field-label">切分方式</span>
+              <el-select
+                :model-value="unstructuredOptions.chunkMethod"
+                aria-label="切分方式"
+                @update:model-value="updateUnstructuredField('chunkMethod', $event)"
+              >
+                <el-option
+                  v-for="method in CHUNK_METHODS"
+                  :key="method.value"
+                  :label="method.label"
+                  :value="method.value"
+                />
+              </el-select>
+              <small>推荐使用自动语义切分，在长度限制内优先保留完整句段</small>
+            </label>
+
+            <label class="config-field">
+              <span class="config-field-label">切片长度</span>
+              <span class="unit-input">
+                <el-input-number
+                  :model-value="unstructuredOptions.chunkSize"
+                  :min="200"
+                  :max="2000"
+                  :step="50"
+                  :precision="0"
+                  controls-position="right"
+                  aria-label="切片长度"
+                  @update:model-value="updateUnstructuredNumber('chunkSize', $event)"
+                />
+                <span>Token</span>
+              </span>
+              <small>单个切片的目标上限，默认 800 Token</small>
+            </label>
+
+            <label class="config-field">
+              <span class="config-field-label">重叠长度</span>
+              <span class="unit-input">
+                <el-input-number
+                  :model-value="unstructuredOptions.chunkOverlap"
+                  :min="0"
+                  :max="500"
+                  :step="10"
+                  :precision="0"
+                  controls-position="right"
+                  aria-label="重叠长度"
+                  @update:model-value="updateUnstructuredNumber('chunkOverlap', $event)"
+                />
+                <span>Token</span>
+              </span>
+              <small>在相邻切片中最多重复保留的上下文，默认 100 Token</small>
+            </label>
+
+            <label class="config-field">
+              <span class="config-field-label">最小切片长度</span>
+              <span class="unit-input">
+                <el-input-number
+                  :model-value="unstructuredOptions.minChunkSize"
+                  :min="20"
+                  :max="500"
+                  :step="10"
+                  :precision="0"
+                  controls-position="right"
+                  aria-label="最小切片长度"
+                  @update:model-value="updateUnstructuredNumber('minChunkSize', $event)"
+                />
+                <span>Token</span>
+              </span>
+              <small>过短的尾部内容会尽量并入前一个切片</small>
+            </label>
+
+            <label
+              v-if="unstructuredOptions.chunkMethod === 'custom'"
+              class="config-field is-full-width"
+            >
+              <span class="config-field-label">自定义分隔符</span>
+              <el-input
+                :model-value="unstructuredOptions.customDelimiter"
+                maxlength="40"
+                show-word-limit
+                placeholder="例如：--- 或 ###"
+                aria-label="自定义分隔符"
+                @update:model-value="updateUnstructuredField('customDelimiter', $event)"
+              />
+              <small>系统会优先在分隔符位置结束当前切片</small>
+            </label>
+          </div>
+
+          <p class="chunk-estimation-note">
+            Token 数为轻量估算值，实际长度以训练使用的模型分词器为准。
+          </p>
+
+          <p v-if="chunkValidationMessage" class="option-validation-message" role="alert">
+            {{ chunkValidationMessage }}
+          </p>
+
+          <div class="preserve-options-panel">
+            <div class="generation-option-copy">
+              <strong>特殊内容保护</strong>
+              <small>避免切分点破坏表格、代码或列表的完整性</small>
+            </div>
+            <div class="preserve-option-grid">
+              <el-checkbox
+                :model-value="unstructuredOptions.preserveTables"
+                @update:model-value="updateUnstructuredField('preserveTables', Boolean($event))"
+              >
+                完整保留表格
+              </el-checkbox>
+              <el-checkbox
+                :model-value="unstructuredOptions.preserveCodeBlocks"
+                @update:model-value="updateUnstructuredField('preserveCodeBlocks', Boolean($event))"
+              >
+                完整保留代码块
+              </el-checkbox>
+              <el-checkbox
+                :model-value="unstructuredOptions.preserveLists"
+                @update:model-value="updateUnstructuredField('preserveLists', Boolean($event))"
+              >
+                完整保留列表
+              </el-checkbox>
+            </div>
+          </div>
+        </div>
+
+        <div class="form-section generation-options-section">
+          <div class="section-title-row">
+            <div>
+              <h3>生成选项</h3>
+              <p>配置每个切片的问答生成方式、范围和输出数量</p>
+            </div>
+          </div>
+          <div class="generation-option-list">
+            <div class="generation-option-row">
+              <div class="generation-option-copy">
+                <strong>语义丰富表达</strong>
+                <small>使用大模型将问答表述得更自然、柔和</small>
+              </div>
+              <el-switch
+                :model-value="unstructuredOptions.semanticEnrichment"
+                inline-prompt
+                active-text="开"
+                inactive-text="关"
+                @update:model-value="updateUnstructuredField('semanticEnrichment', Boolean($event))"
+              />
+            </div>
+
+            <div class="generation-option-row">
+              <div class="generation-option-copy">
+                <strong>每个切片生成数量</strong>
+                <small>每个内容切片最多生成 3 个不同角度的问答对</small>
+              </div>
+              <el-input-number
+                :model-value="unstructuredOptions.qaPairsPerChunk"
+                :min="1"
+                :max="3"
+                :step="1"
+                :precision="0"
+                controls-position="right"
+                @update:model-value="updateUnstructuredNumber('qaPairsPerChunk', $event)"
+              />
+            </div>
+
+            <div class="generation-option-row">
+              <div class="generation-option-copy">
+                <strong>上下文范围</strong>
+                <small>生成问答时可参考的文档范围</small>
+              </div>
+              <el-select
+                :model-value="unstructuredOptions.contextScope"
+                class="compact-select"
+                aria-label="上下文范围"
+                @update:model-value="updateUnstructuredField('contextScope', $event)"
+              >
+                <el-option
+                  v-for="scope in CONTEXT_SCOPES"
+                  :key="scope.value"
+                  :label="scope.label"
+                  :value="scope.value"
+                />
+              </el-select>
+            </div>
+
+            <div class="generation-option-row is-stacked">
+              <div class="generation-option-copy">
+                <strong>问题类型</strong>
+                <small>按内容特点选择要生成的问答角度，至少保留一项</small>
+              </div>
+              <el-checkbox-group
+                :model-value="unstructuredOptions.generationTypes"
+                class="generation-type-grid"
+                @update:model-value="updateGenerationTypes"
+              >
+                <el-checkbox
+                  v-for="type in GENERATION_TYPES"
+                  :key="type.value"
+                  :value="type.value"
+                >
+                  {{ type.label }}
+                </el-checkbox>
+              </el-checkbox-group>
+              <span
+                v-if="unstructuredOptions.generationTypes.length === 0"
+                class="option-validation-message"
+                role="alert"
+              >
+                请至少选择一种问题类型
+              </span>
+            </div>
+
+            <div class="generation-option-row">
+              <div class="generation-option-copy">
+                <strong>跳过无法回答的内容</strong>
+                <small>当切片缺少完整信息时，不强行编造问答对</small>
+              </div>
+              <el-switch
+                :model-value="unstructuredOptions.skipUnanswerable"
+                inline-prompt
+                active-text="开"
+                inactive-text="关"
+                @update:model-value="updateUnstructuredField('skipUnanswerable', Boolean($event))"
+              />
+            </div>
+
+            <div class="generation-option-row dataset-split-row">
+              <div class="generation-option-copy">
+                <strong>数据集划分</strong>
+                <small>按比例将生成后的问答对随机划分为训练集、验证集和测试集</small>
+              </div>
+              <div class="dataset-split-config">
+                <div class="dataset-split-grid">
+                  <label class="dataset-split-field">
+                    <span>训练集</span>
+                    <span class="dataset-split-input">
+                      <el-input-number
+                        :model-value="unstructuredOptions.datasetSplit.train"
+                        :min="0"
+                        :max="100"
+                        :step="1"
+                        :precision="0"
+                        controls-position="right"
+                        aria-label="非结构化训练集比例"
+                        @update:model-value="updateUnstructuredDatasetSplit('train', $event)"
+                      />
+                      <span>%</span>
+                    </span>
+                  </label>
+                  <label class="dataset-split-field">
+                    <span>验证集</span>
+                    <span class="dataset-split-input">
+                      <el-input-number
+                        :model-value="unstructuredOptions.datasetSplit.validation"
+                        :min="0"
+                        :max="100"
+                        :step="1"
+                        :precision="0"
+                        controls-position="right"
+                        aria-label="非结构化验证集比例"
+                        @update:model-value="updateUnstructuredDatasetSplit('validation', $event)"
+                      />
+                      <span>%</span>
+                    </span>
+                  </label>
+                  <label class="dataset-split-field">
+                    <span>测试集</span>
+                    <span class="dataset-split-input">
+                      <el-input-number
+                        :model-value="unstructuredOptions.datasetSplit.test"
+                        :min="0"
+                        :max="100"
+                        :step="1"
+                        :precision="0"
+                        controls-position="right"
+                        aria-label="非结构化测试集比例"
+                        @update:model-value="updateUnstructuredDatasetSplit('test', $event)"
+                      />
+                      <span>%</span>
+                    </span>
+                  </label>
+                </div>
+                <div class="dataset-split-summary" :class="{ 'is-invalid': unstructuredSplitTotal !== 100 }">
+                  <span>总计 {{ unstructuredSplitTotal }}%</span>
+                  <span v-if="unstructuredSplitTotal !== 100" role="alert">
+                    训练集、验证集和测试集比例总和必须为 100%
+                  </span>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </template>
+
      <div v-if="isExternal" class="form-section external-section">
        <div class="section-title-row">
          <div>
@@ -405,6 +1034,222 @@ defineExpose({ validate })
  gap: 20px;
 }

+.preprocess-option-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px;
+  margin-top: 16px;
+}
+
+.preprocess-option {
+  width: 100%;
+  min-height: 64px;
+  margin-right: 0;
+  padding: 12px 14px;
+  box-sizing: border-box;
+  align-items: flex-start;
+  border: 1px solid #e2e5ec;
+  border-radius: 8px;
+  transition: border-color 0.18s ease, background-color 0.18s ease;
+
+  &:hover {
+    border-color: #b7b2f7;
+  }
+
+  &.is-checked {
+    background: #fafaff;
+    border-color: #8b82f4;
+  }
+
+  :deep(.el-checkbox__input) {
+    margin-top: 3px;
+  }
+
+  :deep(.el-checkbox__label) {
+    min-width: 0;
+    padding-left: 10px;
+    white-space: normal;
+  }
+}
+
+.preprocess-option-copy,
+.generation-option-copy {
+  display: grid;
+  gap: 4px;
+
+  strong {
+    color: #344054;
+    font-size: 13px;
+    font-weight: 600;
+  }
+
+  small {
+    color: #8a93a3;
+    font-size: 12px;
+    line-height: 1.5;
+  }
+}
+
+.generation-option-list {
+  display: grid;
+  gap: 12px;
+  margin-top: 16px;
+}
+
+.chunk-settings-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px;
+  margin-top: 16px;
+}
+
+.config-field {
+  display: grid;
+  align-content: start;
+  gap: 8px;
+  min-width: 0;
+  padding: 14px;
+  color: #344054;
+  background: #fbfcfe;
+  border: 1px solid #e2e5ec;
+  border-radius: 8px;
+
+  &.is-full-width {
+    grid-column: 1 / -1;
+  }
+
+  > small {
+    color: #8a93a3;
+    font-size: 12px;
+    line-height: 1.5;
+  }
+
+  :deep(.el-select),
+  :deep(.el-input) {
+    width: 100%;
+  }
+}
+
+.config-field-label {
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.unit-input {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  color: #7b8495;
+  font-size: 12px;
+
+  :deep(.el-input-number) {
+    width: 100%;
+  }
+}
+
+.option-validation-message {
+  display: block;
+  margin: 8px 0 0;
+  color: #dc2626;
+  font-size: 12px;
+  line-height: 1.5;
+}
+
+.chunk-estimation-note {
+  margin: 9px 0 0;
+  color: #8a93a3;
+  font-size: 12px;
+  line-height: 1.5;
+}
+
+.preserve-options-panel {
+  display: grid;
+  gap: 12px;
+  margin-top: 12px;
+  padding: 14px;
+  border: 1px solid #e2e5ec;
+  border-radius: 8px;
+}
+
+.preserve-option-grid,
+.generation-type-grid {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px 24px;
+
+  :deep(.el-checkbox) {
+    margin-right: 0;
+  }
+}
+
+.generation-option-row {
+  display: flex;
+  min-height: 64px;
+  align-items: center;
+  justify-content: space-between;
+  gap: 24px;
+  padding: 12px 14px;
+  box-sizing: border-box;
+  border: 1px solid #e2e5ec;
+  border-radius: 8px;
+}
+
+.generation-option-row.is-stacked {
+  align-items: stretch;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.compact-select {
+  width: 220px;
+  max-width: 100%;
+}
+
+.dataset-split-row {
+  align-items: stretch;
+  flex-direction: column;
+}
+
+.dataset-split-config {
+  display: grid;
+  gap: 10px;
+}
+
+.dataset-split-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 16px;
+}
+
+.dataset-split-field {
+  display: grid;
+  gap: 7px;
+  color: #5f6878;
+  font-size: 12px;
+}
+
+.dataset-split-input {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+
+  :deep(.el-input-number) {
+    width: 100%;
+  }
+}
+
+.dataset-split-summary {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  color: #2ca66a;
+  font-size: 12px;
+
+  &.is-invalid {
+    color: #dc2626;
+  }
+}
+
 .section-title-row {
  display: flex;
  align-items: flex-start;
@@ -650,6 +1495,32 @@ defineExpose({ validate })
    grid-template-columns: minmax(0, 1fr);
  }

+  .preprocess-option-grid {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .chunk-settings-grid {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .config-field.is-full-width {
+    grid-column: auto;
+  }
+
+  .dataset-split-grid {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .dataset-split-summary {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .generation-option-row:not(.dataset-split-row):not(.is-stacked) {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
  .external-section .external-grid {
    grid-template-columns: minmax(0, 1fr);
  }
--- a/frontend/src/views/data-process/create/previewModel.ts
+++ b/frontend/src/views/data-process/create/previewModel.ts
@@ -1,4 +1,11 @@
-import type { PreviewItem, ProcessType, ResultItem, SourceLine } from './types'
+import type {
+  PreviewItem,
+  ProcessType,
+  ResultItem,
+  SourceLine,
+  StructuredProcessOptions,
+  UnstructuredProcessOptions,
+} from './types'

 export const DEFAULT_SOURCE_TEXT = [
  '问：如何看待当前的通货膨胀风险？',
@@ -39,8 +46,417 @@ export function sourceLines(sourceText: string): SourceLine[] {
  })
 }

-export function buildPreviewItems(sourceText: string, processType: ProcessType, sourceFileId = 'default-source'): PreviewItem[] {
-  const meaningfulLines = sourceLines(sourceText).filter((line) => line.content.trim())
+interface SourceRange {
+  start: number
+  end: number
+}
+
+interface ProtectedRange extends SourceRange {
+  kind: 'code' | 'table' | 'list'
+}
+
+const DEFAULT_CHUNK_SIZE = 800
+const DEFAULT_CHUNK_OVERLAP = 100
+const DEFAULT_MIN_CHUNK_SIZE = 100
+
+function finiteInteger(value: number | undefined, fallback: number, min: number): number {
+  return Number.isFinite(value) ? Math.max(min, Math.round(value as number)) : fallback
+}
+
+function trimSourceRange(sourceText: string, start: number, end: number): SourceRange {
+  let nextStart = Math.max(0, start)
+  let nextEnd = Math.min(sourceText.length, end)
+
+  while (nextStart < nextEnd && /\s/.test(sourceText[nextStart])) nextStart += 1
+  while (nextEnd > nextStart && /\s/.test(sourceText[nextEnd - 1])) nextEnd -= 1
+
+  return { start: nextStart, end: nextEnd }
+}
+
+function normalizeDelimiter(delimiter: string | undefined): string {
+  return (delimiter ?? '').replace(/\\n/g, '\n').replace(/\\t/g, '\t')
+}
+
+function overlapsRange(line: SourceLine, range: SourceRange): boolean {
+  return line.start < range.end && line.end > range.start
+}
+
+function isLineProtected(line: SourceLine, ranges: SourceRange[]): boolean {
+  return ranges.some((range) => overlapsRange(line, range))
+}
+
+function detectCodeBlockRanges(sourceText: string, lines: SourceLine[]): ProtectedRange[] {
+  const ranges: ProtectedRange[] = []
+  let openFence: { start: number; marker: string; length: number } | null = null
+
+  for (const line of lines) {
+    const fence = line.content.match(/^\s*(`{3,}|~{3,})/)
+    if (!fence) continue
+
+    const marker = fence[1][0]
+    if (!openFence) {
+      openFence = { start: line.start, marker, length: fence[1].length }
+      continue
+    }
+
+    if (marker === openFence.marker && fence[1].length >= openFence.length) {
+      ranges.push({ start: openFence.start, end: line.end, kind: 'code' })
+      openFence = null
+    }
+  }
+
+  if (openFence) ranges.push({ start: openFence.start, end: sourceText.length, kind: 'code' })
+  return ranges
+}
+
+function isTableSeparator(content: string): boolean {
+  const normalized = content.trim().replace(/^\|/, '').replace(/\|$/, '')
+  const cells = normalized.split('|').map((cell) => cell.trim())
+  return cells.length >= 2 && cells.every((cell) => /^:?-{3,}:?$/.test(cell))
+}
+
+function detectTableRanges(lines: SourceLine[], codeRanges: SourceRange[]): ProtectedRange[] {
+  const ranges: ProtectedRange[] = []
+
+  for (let index = 0; index < lines.length - 1; index += 1) {
+    const header = lines[index]
+    const separator = lines[index + 1]
+    if (
+      isLineProtected(header, codeRanges)
+      || isLineProtected(separator, codeRanges)
+      || !header.content.includes('|')
+      || !isTableSeparator(separator.content)
+    ) {
+      continue
+    }
+
+    let endIndex = index + 1
+    while (
+      endIndex + 1 < lines.length
+      && !isLineProtected(lines[endIndex + 1], codeRanges)
+      && lines[endIndex + 1].content.trim()
+      && lines[endIndex + 1].content.includes('|')
+    ) {
+      endIndex += 1
+    }
+
+    ranges.push({ start: header.start, end: lines[endIndex].end, kind: 'table' })
+    index = endIndex
+  }
+
+  return ranges
+}
+
+function isListItem(content: string): boolean {
+  return /^\s*(?:[-+*]|\d+[.)])\s+\S/.test(content)
+}
+
+function isListContinuation(content: string): boolean {
+  return /^\s{2,}\S/.test(content)
+}
+
+function detectListRanges(
+  lines: SourceLine[],
+  excludedRanges: SourceRange[],
+): ProtectedRange[] {
+  const ranges: ProtectedRange[] = []
+
+  for (let index = 0; index < lines.length; index += 1) {
+    if (isLineProtected(lines[index], excludedRanges) || !isListItem(lines[index].content)) continue
+
+    let endIndex = index
+    let itemCount = 1
+    while (endIndex + 1 < lines.length && !isLineProtected(lines[endIndex + 1], excludedRanges)) {
+      const nextContent = lines[endIndex + 1].content
+      if (isListItem(nextContent)) {
+        itemCount += 1
+        endIndex += 1
+        continue
+      }
+      if (isListContinuation(nextContent)) {
+        endIndex += 1
+        continue
+      }
+      break
+    }
+
+    if (itemCount >= 2) {
+      ranges.push({ start: lines[index].start, end: lines[endIndex].end, kind: 'list' })
+      index = endIndex
+    }
+  }
+
+  return ranges
+}
+
+function mergeProtectedRanges(ranges: ProtectedRange[]): ProtectedRange[] {
+  return ranges
+    .sort((left, right) => left.start - right.start || left.end - right.end)
+    .reduce<ProtectedRange[]>((merged, range) => {
+      const previous = merged[merged.length - 1]
+      if (previous && range.start < previous.end) {
+        previous.end = Math.max(previous.end, range.end)
+        return merged
+      }
+      merged.push({ ...range })
+      return merged
+    }, [])
+}
+
+function protectedRangesForOptions(
+  sourceText: string,
+  options?: UnstructuredProcessOptions,
+): ProtectedRange[] {
+  if (!options?.preserveCodeBlocks && !options?.preserveTables && !options?.preserveLists) return []
+
+  const lines = sourceLines(sourceText)
+  const codeRanges = detectCodeBlockRanges(sourceText, lines)
+  const tableRanges = detectTableRanges(lines, codeRanges)
+  const listRanges = detectListRanges(lines, [...codeRanges, ...tableRanges])
+  const enabledRanges = [
+    ...(options?.preserveCodeBlocks ? codeRanges : []),
+    ...(options?.preserveTables ? tableRanges : []),
+    ...(options?.preserveLists ? listRanges : []),
+  ]
+
+  return mergeProtectedRanges(enabledRanges)
+}
+
+function protectedRangeContaining(
+  ranges: ProtectedRange[],
+  offset: number,
+): ProtectedRange | undefined {
+  return ranges.find((range) => range.start < offset && offset < range.end)
+}
+
+function normalizeChunkStart(
+  sourceText: string,
+  cursor: number,
+  protectedRanges: ProtectedRange[],
+): number {
+  let start = Math.max(0, Math.min(cursor, sourceText.length))
+  const overlapBlock = protectedRangeContaining(protectedRanges, start)
+  if (overlapBlock) start = overlapBlock.end
+
+  while (start < sourceText.length && /\s/.test(sourceText[start])) start += 1
+
+  // 去除块前空白时可能进入缩进代码块/列表；此时恢复到完整块起点。
+  const blockAfterTrim = protectedRangeContaining(protectedRanges, start)
+  if (blockAfterTrim) return cursor <= blockAfterTrim.start ? blockAfterTrim.start : blockAfterTrim.end
+
+  return start
+}
+
+function protectChunkEnd(
+  proposedEnd: number,
+  start: number,
+  minimumEnd: number,
+  protectedRanges: ProtectedRange[],
+): number {
+  const splitBlock = protectedRangeContaining(protectedRanges, proposedEnd)
+  if (!splitBlock) return proposedEnd
+
+  // 优先在块前结束；块前不足最小切片长度时，将整个块收入当前切片。
+  return splitBlock.start > start && splitBlock.start >= minimumEnd
+    ? splitBlock.start
+    : splitBlock.end
+}
+
+function restoreProtectedEdges(
+  range: SourceRange,
+  rawStart: number,
+  rawEnd: number,
+  protectedRanges: ProtectedRange[],
+): SourceRange {
+  const nextRange = { ...range }
+  const startBlock = protectedRangeContaining(protectedRanges, nextRange.start)
+  if (startBlock && rawStart <= startBlock.start) nextRange.start = startBlock.start
+
+  const endBlock = protectedRangeContaining(protectedRanges, nextRange.end)
+  if (endBlock && rawEnd >= endBlock.end) nextRange.end = endBlock.end
+  return nextRange
+}
+
+function lastBoundaryInRange(
+  sourceText: string,
+  idealEnd: number,
+  minimumEnd: number,
+): number | null {
+  const candidates: number[] = []
+  const boundaryTokens = ['\n\n', '\n', '。', '！', '？', '；', '.', '!', '?', ';']
+
+  boundaryTokens.forEach((token) => {
+    const tokenStart = sourceText.lastIndexOf(token, idealEnd - token.length)
+    const boundary = tokenStart === -1 ? -1 : tokenStart + token.length
+    if (boundary >= minimumEnd && boundary <= idealEnd) candidates.push(boundary)
+  })
+
+  return candidates.length ? Math.max(...candidates) : null
+}
+
+function lastHeadingBoundary(
+  sourceText: string,
+  start: number,
+  idealEnd: number,
+  minimumEnd: number,
+): number | null {
+  const section = sourceText.slice(start, idealEnd)
+  const headingPattern = /^(?:#{1,6}\s+|第[一二三四五六七八九十百]+[章节篇部分]|\d+(?:\.\d+)*[、.\s])/gm
+  let boundary: number | null = null
+  let match: RegExpExecArray | null
+
+  while ((match = headingPattern.exec(section))) {
+    const absoluteStart = start + match.index
+    if (absoluteStart >= minimumEnd) boundary = absoluteStart
+  }
+
+  return boundary
+}
+
+function resolveChunkEnd(
+  sourceText: string,
+  start: number,
+  idealEnd: number,
+  minimumEnd: number,
+  options: UnstructuredProcessOptions | undefined,
+): number {
+  const method = options?.chunkMethod ?? 'semantic'
+
+  if (method === 'fixed') return idealEnd
+
+  if (method === 'custom') {
+    const delimiter = normalizeDelimiter(options?.customDelimiter)
+    if (!delimiter) return idealEnd
+
+    const delimiterStart = sourceText.lastIndexOf(delimiter, idealEnd - delimiter.length)
+    const boundary = delimiterStart === -1 ? -1 : delimiterStart + delimiter.length
+    return boundary >= minimumEnd ? boundary : idealEnd
+  }
+
+  if (method === 'heading') {
+    const headingBoundary = lastHeadingBoundary(sourceText, start, idealEnd, minimumEnd)
+    if (headingBoundary !== null) return headingBoundary
+  }
+
+  return lastBoundaryInRange(sourceText, idealEnd, minimumEnd) ?? idealEnd
+}
+
+function buildUnstructuredRanges(
+  sourceText: string,
+  options?: UnstructuredProcessOptions,
+): SourceRange[] {
+  // 预览统一沿用“约 2 个字符 = 1 token”的轻量估算，避免引入分词器依赖。
+  const targetCharacters = finiteInteger(options?.chunkSize, DEFAULT_CHUNK_SIZE, 1) * 2
+  const minimumCharacters = Math.min(
+    targetCharacters,
+    finiteInteger(options?.minChunkSize, DEFAULT_MIN_CHUNK_SIZE, 1) * 2,
+  )
+  const requestedOverlap = finiteInteger(options?.chunkOverlap, DEFAULT_CHUNK_OVERLAP, 0) * 2
+  const protectedRanges = protectedRangesForOptions(sourceText, options)
+  const ranges: SourceRange[] = []
+  let cursor = 0
+
+  while (cursor < sourceText.length) {
+    const start = normalizeChunkStart(sourceText, cursor, protectedRanges)
+    if (start >= sourceText.length) break
+
+    const idealEnd = Math.min(sourceText.length, start + targetCharacters)
+    const minimumEnd = Math.min(idealEnd, start + minimumCharacters)
+    let end = idealEnd === sourceText.length
+      ? idealEnd
+      : resolveChunkEnd(sourceText, start, idealEnd, minimumEnd, options)
+    end = protectChunkEnd(end, start, minimumEnd, protectedRanges)
+
+    // 所有自定义边界都必须向前推进；异常配置回退到固定长度切分。
+    if (end <= start) end = Math.min(sourceText.length, start + targetCharacters)
+
+    let range = trimSourceRange(sourceText, start, end)
+    range = restoreProtectedEdges(range, start, end, protectedRanges)
+    if (end < sourceText.length && range.end - range.start < minimumCharacters) {
+      range.end = Math.min(end, range.start + minimumCharacters)
+    }
+    if (range.end <= range.start) {
+      cursor = Math.max(cursor + 1, end)
+      continue
+    }
+
+    const isLastRange = end >= sourceText.length
+    if (isLastRange && range.end - range.start < minimumCharacters && ranges.length) {
+      ranges[ranges.length - 1].end = range.end
+      break
+    }
+
+    ranges.push(range)
+    if (isLastRange) break
+
+    // overlap 是允许的最大重叠量；按当前切片动态收缩，保证每轮至少推进最小切片长度。
+    const maximumOverlap = Math.max(0, range.end - range.start - minimumCharacters)
+    const actualOverlap = Math.min(requestedOverlap, maximumOverlap)
+    const nextCursor = range.end - actualOverlap
+    cursor = nextCursor > start ? nextCursor : range.end
+  }
+
+  return ranges
+}
+
+function lineNumberAtOffset(lines: SourceLine[], offset: number): number | null {
+  if (!lines.length) return null
+
+  let low = 0
+  let high = lines.length - 1
+  let result = 0
+
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2)
+    if (lines[middle].start <= offset) {
+      result = middle
+      low = middle + 1
+    } else {
+      high = middle - 1
+    }
+  }
+
+  return lines[result].number
+}
+
+function previewItemFromRange(
+  sourceText: string,
+  lines: SourceLine[],
+  range: SourceRange,
+  sourceFileId: string,
+  index: number,
+): PreviewItem {
+  const content = sourceText.slice(range.start, range.end)
+
+  return {
+    id: `preview-${sourceFileId}-${index + 1}`,
+    sourceFileId,
+    originalContent: content,
+    editedContent: content,
+    sourceStart: range.start,
+    sourceEnd: range.end,
+    sourceStartLine: lineNumberAtOffset(lines, range.start),
+    sourceEndLine: lineNumberAtOffset(lines, Math.max(range.start, range.end - 1)),
+    tokenCount: Math.max(1, Math.ceil(content.length / 2)),
+    status: 'original',
+  }
+}
+
+export function buildPreviewItems(
+  sourceText: string,
+  processType: ProcessType,
+  sourceFileId = 'default-source',
+  unstructuredOptions?: UnstructuredProcessOptions,
+): PreviewItem[] {
+  const lines = sourceLines(sourceText)
+
+  if (processType === 'unstructured') {
+    return buildUnstructuredRanges(sourceText, unstructuredOptions).map((range, index) => (
+      previewItemFromRange(sourceText, lines, range, sourceFileId, index)
+    ))
+  }
+
+  const meaningfulLines = lines.filter((line) => line.content.trim())
  const groupSize = processType === 'structured' ? 1 : 3
  const items: PreviewItem[] = []

@@ -69,21 +485,44 @@ export function buildPreviewItems(sourceText: string, processType: ProcessType,
  return items
 }

-export function createResults(items: PreviewItem[]): ResultItem[] {
-  return items.slice(0, 12).map((item, index) => {
+const SEMANTIC_PREFIXES = [
+  '请结合实际情况，说明一下：',
+  '如果方便的话，请详细解答：',
+  '请用通俗易懂的方式说明：',
+  '请从实际应用角度说明：',
+  '请简洁、自然地说明：',
+]
+
+export function createResults(
+  items: PreviewItem[],
+  options?: StructuredProcessOptions | UnstructuredProcessOptions,
+): ResultItem[] {
+  const resultCount = options && 'qaPairsPerChunk' in options
+    ? Math.min(3, finiteInteger(options.qaPairsPerChunk, 1, 1))
+    : Math.min(5, finiteInteger(options?.qaPairsPerRow, 1, 1))
+
+  return items.flatMap((item, index) => {
    const [firstLine = '', ...rest] = item.editedContent.split('\n')
    const output = rest.join('\n').trim() || item.editedContent.trim()
-    const instruction = firstLine.replace(/^问[:：]\s*/, '').trim() || `数据条目 ${index + 1}`
+    const baseInstruction = firstLine.replace(/^问[:：]\s*/, '').trim() || `数据条目 ${index + 1}`

-    return {
-      id: `result-${index + 1}`,
-      instruction,
-      input: '',
-      output,
-      originalInstruction: instruction,
-      originalInput: '',
-      originalOutput: output,
-      status: 'valid',
-    }
+    return Array.from({ length: resultCount }, (_, variantIndex) => {
+      const instruction = options?.semanticEnrichment
+        ? `${SEMANTIC_PREFIXES[variantIndex]}${baseInstruction}`
+        : variantIndex === 0
+          ? baseInstruction
+          : `${baseInstruction}（问法 ${variantIndex + 1}）`
+
+      return {
+        id: resultCount === 1 ? `result-${index + 1}` : `result-${index + 1}-${variantIndex + 1}`,
+        instruction,
+        input: '',
+        output,
+        originalInstruction: instruction,
+        originalInput: '',
+        originalOutput: output,
+        status: 'valid' as const,
+      }
+    })
  })
 }
--- a/frontend/src/views/data-process/create/types.ts
+++ b/frontend/src/views/data-process/create/types.ts
@@ -2,6 +2,65 @@ export type ProcessType = 'structured' | 'unstructured' | 'external'

 export type StepId = 'create' | 'preview' | 'generate' | 'results'

+export type PreprocessOption =
+  | 'clean_invalid'
+  | 'detect_structure'
+  | 'deduplicate'
+  | 'normalize_format'
+  | 'filter_anomaly'
+  | 'desensitize'
+
+export interface DatasetSplitOptions {
+  train: number
+  validation: number
+  test: number
+}
+
+export interface StructuredProcessOptions {
+  preprocessOptions: PreprocessOption[]
+  semanticEnrichment: boolean
+  qaPairsPerRow: number
+  datasetSplit: DatasetSplitOptions
+}
+
+export type UnstructuredPreprocessOption =
+  | 'clean_invalid_content'
+  | 'detect_document_structure'
+  | 'merge_short_content'
+  | 'filter_low_quality'
+  | 'deduplicate_content'
+  | 'desensitize'
+  | 'preserve_context'
+
+export type ChunkMethod = 'semantic' | 'heading' | 'fixed' | 'custom'
+
+export type GenerationContextScope = 'current' | 'adjacent' | 'section'
+
+export type QuestionGenerationType =
+  | 'factual'
+  | 'concept'
+  | 'procedure'
+  | 'reasoning'
+  | 'comprehensive'
+
+export interface UnstructuredProcessOptions {
+  preprocessOptions: UnstructuredPreprocessOption[]
+  chunkMethod: ChunkMethod
+  chunkSize: number
+  chunkOverlap: number
+  minChunkSize: number
+  customDelimiter: string
+  preserveTables: boolean
+  preserveCodeBlocks: boolean
+  preserveLists: boolean
+  semanticEnrichment: boolean
+  qaPairsPerChunk: number
+  contextScope: GenerationContextScope
+  generationTypes: QuestionGenerationType[]
+  skipUnanswerable: boolean
+  datasetSplit: DatasetSplitOptions
+}
+
 export interface ExternalDataSource {
  type: string
  url: string