feat(annotation): 优化文本标注分段功能实现

- 新增 getEditorTaskSegmentsUsingGet 接口用于获取任务分段信息 - 移除 SegmentInfo 中的 text、start、end 字段，精简数据结构 - 添加 EditorTaskSegmentsResponse 类型定义用于分段摘要响应 - 实现服务端 get_task_segments 方法，支持分段信息查询 - 重构前端组件缓存机制，使用 segmentSummaryFileRef 管理分段状态 - 优化分段构建逻辑，提取 _build_segment_contexts 公共方法 - 调整后端 _build_text_task 方法中的分段处理流程 - 更新 API 类型定义，统一 RequestParams 和 RequestPayload 类型
feat(data-management): 添加数据集文件取消上传功能
2026-02-04 16:59:04 +08:00 · 2026-02-04 16:25:03 +08:00 · 2026-02-04 16:11:03 +08:00 · 2026-02-04 15:58:58 +08:00 · 2026-02-04 15:48:01 +08:00 · 2026-02-04 15:43:53 +08:00
18 changed files with 1987 additions and 664 deletions
--- a/backend/openapi/specs/data-management.yaml
+++ b/backend/openapi/specs/data-management.yaml
@@ -447,12 +447,12 @@ paths:
              schema:
                type: string

-  /data-management/datasets/{datasetId}/files/upload/chunk:
-    post:
-      tags: [ DatasetFile ]
-      operationId: chunkUpload
-      summary: 切片上传
-      description: 使用预上传返回的请求ID进行分片上传
+  /data-management/datasets/{datasetId}/files/upload/chunk:
+    post:
+      tags: [ DatasetFile ]
+      operationId: chunkUpload
+      summary: 切片上传
+      description: 使用预上传返回的请求ID进行分片上传
      parameters:
        - name: datasetId
          in: path
@@ -466,15 +466,32 @@ paths:
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/UploadFileRequest'
-      responses:
-        '200':
-          description: 上传成功
-
-  /data-management/dataset-types:
-    get:
-      operationId: getDatasetTypes
-      tags: [DatasetType]
-      summary: 获取数据集类型列表
+      responses:
+        '200':
+          description: 上传成功
+
+  /data-management/datasets/upload/cancel-upload/{reqId}:
+    put:
+      tags: [ DatasetFile ]
+      operationId: cancelUpload
+      summary: 取消上传
+      description: 取消预上传请求并清理临时分片
+      parameters:
+        - name: reqId
+          in: path
+          required: true
+          schema:
+            type: string
+          description: 预上传请求ID
+      responses:
+        '200':
+          description: 取消成功
+
+  /data-management/dataset-types:
+    get:
+      operationId: getDatasetTypes
+      tags: [DatasetType]
+      summary: 获取数据集类型列表
      description: 获取所有支持的数据集类型
      responses:
        '200':
--- a/backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetApplicationService.java
+++ b/backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetApplicationService.java
@@ -1,5 +1,6 @@
 package com.datamate.datamanagement.application;

+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.datamate.common.domain.utils.ChunksSaver;
@@ -101,6 +102,7 @@ public class DatasetApplicationService {
    public Dataset updateDataset(String datasetId, UpdateDatasetRequest updateDatasetRequest) {
        Dataset dataset = datasetRepository.getById(datasetId);
        BusinessAssert.notNull(dataset, DataManagementErrorCode.DATASET_NOT_FOUND);
+        
        if (StringUtils.hasText(updateDatasetRequest.getName())) {
            dataset.setName(updateDatasetRequest.getName());
        }
@@ -113,13 +115,31 @@ public class DatasetApplicationService {
        if (Objects.nonNull(updateDatasetRequest.getStatus())) {
            dataset.setStatus(updateDatasetRequest.getStatus());
        }
-        if (updateDatasetRequest.getParentDatasetId() != null) {
+        if (updateDatasetRequest.isParentDatasetIdProvided()) {
+            // 保存原始的 parentDatasetId 值，用于比较是否发生了变化
+            String originalParentDatasetId = dataset.getParentDatasetId();
+
+            // 处理父数据集变更：仅当请求显式包含 parentDatasetId 时处理
+            // handleParentChange 内部通过 normalizeParentId 方法将空字符串和 null 都转换为 null
+            // 这样既支持设置新的父数据集，也支持清除关联
            handleParentChange(dataset, updateDatasetRequest.getParentDatasetId());
+
+            // 检查 parentDatasetId 是否发生了变化
+            if (!Objects.equals(originalParentDatasetId, dataset.getParentDatasetId())) {
+                // 使用 LambdaUpdateWrapper 显式地更新 parentDatasetId 字段
+                // 这样即使值为 null 也能被正确更新到数据库
+                datasetRepository.update(null, new LambdaUpdateWrapper<Dataset>()
+                    .eq(Dataset::getId, datasetId)
+                    .set(Dataset::getParentDatasetId, dataset.getParentDatasetId()));
+            }
        }
+        
        if (StringUtils.hasText(updateDatasetRequest.getDataSource())) {
            // 数据源id不为空，使用异步线程进行文件扫盘落库
            processDataSourceAsync(dataset.getId(), updateDatasetRequest.getDataSource());
        }
+        
+        // 更新其他字段（不包括 parentDatasetId，因为它已经在上面的代码中更新了）
        datasetRepository.updateById(dataset);
        return dataset;
    }
--- a/backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetFileApplicationService.java
+++ b/backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetFileApplicationService.java
@@ -499,11 +499,19 @@ public class DatasetFileApplicationService {
     *
     * @param uploadFileRequest 上传请求
     */
-    @Transactional
-    public void chunkUpload(String datasetId, UploadFileRequest uploadFileRequest) {
-        FileUploadResult uploadResult = fileService.chunkUpload(DatasetConverter.INSTANCE.toChunkUploadRequest(uploadFileRequest));
-        saveFileInfoToDb(uploadResult, datasetId);
-    }
+    @Transactional
+    public void chunkUpload(String datasetId, UploadFileRequest uploadFileRequest) {
+        FileUploadResult uploadResult = fileService.chunkUpload(DatasetConverter.INSTANCE.toChunkUploadRequest(uploadFileRequest));
+        saveFileInfoToDb(uploadResult, datasetId);
+    }
+
+    /**
+     * 取消上传
+     */
+    @Transactional
+    public void cancelUpload(String reqId) {
+        fileService.cancelUpload(reqId);
+    }

    private void saveFileInfoToDb(FileUploadResult fileUploadResult, String datasetId) {
        if (Objects.isNull(fileUploadResult.getSavedFile())) {
--- a/backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/UpdateDatasetRequest.java
+++ b/backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/UpdateDatasetRequest.java
@@ -1,8 +1,10 @@
 package com.datamate.datamanagement.interfaces.dto;

 import com.datamate.datamanagement.common.enums.DatasetStatusType;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.Size;
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.Setter;

@@ -24,9 +26,18 @@ public class UpdateDatasetRequest {
    /** 归集任务id */
    private String dataSource;
    /** 父数据集ID */
+    @Setter(AccessLevel.NONE)
    private String parentDatasetId;
+    @JsonIgnore
+    @Setter(AccessLevel.NONE)
+    private boolean parentDatasetIdProvided;
    /** 标签列表 */
    private List<String> tags;
    /** 数据集状态 */
    private DatasetStatusType status;
+
+    public void setParentDatasetId(String parentDatasetId) {
+        this.parentDatasetIdProvided = true;
+        this.parentDatasetId = parentDatasetId;
+    }
 }
--- a/backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/DatasetUploadController.java
+++ b/backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/DatasetUploadController.java
@@ -0,0 +1,33 @@
+package com.datamate.datamanagement.interfaces.rest;
+
+import com.datamate.datamanagement.application.DatasetFileApplicationService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 数据集上传控制器
+ */
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/data-management/datasets/upload")
+public class DatasetUploadController {
+
+    private final DatasetFileApplicationService datasetFileApplicationService;
+
+    /**
+     * 取消上传
+     *
+     * @param reqId 预上传请求ID
+     */
+    @PutMapping("/cancel-upload/{reqId}")
+    public ResponseEntity<Void> cancelUpload(@PathVariable("reqId") String reqId) {
+        datasetFileApplicationService.cancelUpload(reqId);
+        return ResponseEntity.ok().build();
+    }
+}
--- a/backend/shared/domain-common/src/main/java/com/datamate/common/domain/service/FileService.java
+++ b/backend/shared/domain-common/src/main/java/com/datamate/common/domain/service/FileService.java
@@ -74,6 +74,26 @@ public class FileService {
            .build();
    }

+    /**
+     * 取消上传
+     */
+    @Transactional
+    public void cancelUpload(String reqId) {
+        if (reqId == null || reqId.isBlank()) {
+            throw BusinessException.of(CommonErrorCode.PARAM_ERROR);
+        }
+        ChunkUploadPreRequest preRequest = chunkUploadRequestMapper.findById(reqId);
+        if (preRequest == null) {
+            return;
+        }
+        String uploadPath = preRequest.getUploadPath();
+        if (uploadPath != null && !uploadPath.isBlank()) {
+            File tempDir = new File(uploadPath, String.format(ChunksSaver.TEMP_DIR_NAME_FORMAT, preRequest.getId()));
+            ChunksSaver.deleteFolder(tempDir.getPath());
+        }
+        chunkUploadRequestMapper.deleteById(reqId);
+    }
+
    private File uploadFile(ChunkUploadRequest fileUploadRequest, ChunkUploadPreRequest preRequest) {
        File savedFile = ChunksSaver.saveFile(fileUploadRequest, preRequest);
        preRequest.setTimeout(LocalDateTime.now().plusSeconds(DEFAULT_TIMEOUT));
--- a/frontend/src/hooks/useSliceUpload.tsx
+++ b/frontend/src/hooks/useSliceUpload.tsx
@@ -1,198 +1,383 @@
-import { TaskItem } from "@/pages/DataManagement/dataset.model";
-import { calculateSHA256, checkIsFilesExist } from "@/utils/file.util";
-import { App } from "antd";
-import { useRef, useState } from "react";
-
-export function useFileSliceUpload(
-  {
-    preUpload,
-    uploadChunk,
-    cancelUpload,
-  }: {
-    preUpload: (id: string, params: any) => Promise<{ data: number }>;
-    uploadChunk: (id: string, formData: FormData, config: any) => Promise<any>;
-    cancelUpload: ((reqId: number) => Promise<any>) | null;
-  },
-  showTaskCenter = true // 上传时是否显示任务中心
-) {
-  const { message } = App.useApp();
-  const [taskList, setTaskList] = useState<TaskItem[]>([]);
-  const taskListRef = useRef<TaskItem[]>([]); // 用于固定任务顺序
-
-  const createTask = (detail: any = {}) => {
-    const { dataset } = detail;
-    const title = `上传数据集: ${dataset.name} `;
-    const controller = new AbortController();
-    const task: TaskItem = {
-      key: dataset.id,
-      title,
-      percent: 0,
-      reqId: -1,
-      controller,
-      size: 0,
-      updateEvent: detail.updateEvent,
-      hasArchive: detail.hasArchive,
-      prefix: detail.prefix,
-    };
-    taskListRef.current = [task, ...taskListRef.current];
-
-    setTaskList(taskListRef.current);
-    return task;
-  };
-
-  const updateTaskList = (task: TaskItem) => {
-    taskListRef.current = taskListRef.current.map((item) =>
-      item.key === task.key ? task : item
-    );
-    setTaskList(taskListRef.current);
-  };
-
-  const removeTask = (task: TaskItem) => {
-    const { key } = task;
-    taskListRef.current = taskListRef.current.filter(
-      (item) => item.key !== key
-    );
-    setTaskList(taskListRef.current);
-    if (task.isCancel && task.cancelFn) {
-      task.cancelFn();
-    }
-    if (task.updateEvent) {
-      // 携带前缀信息，便于刷新后仍停留在当前目录
-      window.dispatchEvent(
-        new CustomEvent(task.updateEvent, {
-          detail: { prefix: (task as any).prefix },
-        })
-      );
-    }
-    if (showTaskCenter) {
-      window.dispatchEvent(
-        new CustomEvent("show:task-popover", { detail: { show: false } })
-      );
-    }
-  };
-
-  async function buildFormData({ file, reqId, i, j }) {
-    const formData = new FormData();
-    const { slices, name, size } = file;
-    const checkSum = await calculateSHA256(slices[j]);
-    formData.append("file", slices[j]);
-    formData.append("reqId", reqId.toString());
-    formData.append("fileNo", (i + 1).toString());
-    formData.append("chunkNo", (j + 1).toString());
-    formData.append("fileName", name);
-    formData.append("fileSize", size.toString());
-    formData.append("totalChunkNum", slices.length.toString());
-    formData.append("checkSumHex", checkSum);
-    return formData;
-  }
-
-  async function uploadSlice(task: TaskItem, fileInfo) {
-    if (!task) {
-      return;
-    }
-    const { reqId, key } = task;
-    const { loaded, i, j, files, totalSize } = fileInfo;
-    const formData = await buildFormData({
-      file: files[i],
-      i,
-      j,
-      reqId,
-    });
-
-    let newTask = { ...task };
-    await uploadChunk(key, formData, {
-      onUploadProgress: (e) => {
-        const loadedSize = loaded + e.loaded;
-        const curPercent = Number((loadedSize / totalSize) * 100).toFixed(2);
-
-        newTask = {
-          ...newTask,
-          ...taskListRef.current.find((item) => item.key === key),
-          size: loadedSize,
-          percent: curPercent >= 100 ? 99.99 : curPercent,
-        };
-        updateTaskList(newTask);
-      },
-    });
-  }
-
-  async function uploadFile({ task, files, totalSize }) {
-    console.log('[useSliceUpload] Calling preUpload with prefix:', task.prefix);
-    const { data: reqId } = await preUpload(task.key, {
-      totalFileNum: files.length,
-      totalSize,
-      datasetId: task.key,
-      hasArchive: task.hasArchive,
-      prefix: task.prefix,
-    });
-    console.log('[useSliceUpload] PreUpload response reqId:', reqId);
-
-    const newTask: TaskItem = {
-      ...task,
-      reqId,
-      isCancel: false,
-      cancelFn: () => {
-        task.controller.abort();
-        cancelUpload?.(reqId);
-        if (task.updateEvent) window.dispatchEvent(new Event(task.updateEvent));
-      },
-    };
-    updateTaskList(newTask);
-    if (showTaskCenter) {
-      window.dispatchEvent(
-        new CustomEvent("show:task-popover", { detail: { show: true } })
-      );
-    }
-    // // 更新数据状态
-    if (task.updateEvent) window.dispatchEvent(new Event(task.updateEvent));
-
-    let loaded = 0;
-    for (let i = 0; i < files.length; i++) {
-      const { slices } = files[i];
-      for (let j = 0; j < slices.length; j++) {
-        await uploadSlice(newTask, {
-          loaded,
-          i,
-          j,
-          files,
-          totalSize,
-        });
-        loaded += slices[j].size;
-      }
-    }
-    removeTask(newTask);
-  }
-
-  const handleUpload = async ({ task, files }) => {
-    const isErrorFile = await checkIsFilesExist(files);
-    if (isErrorFile) {
-      message.error("文件被修改或删除，请重新选择文件上传");
-      removeTask({
-        ...task,
-        isCancel: false,
-        ...taskListRef.current.find((item) => item.key === task.key),
-      });
-      return;
-    }
-
-    try {
-      const totalSize = files.reduce((acc, file) => acc + file.size, 0);
-      await uploadFile({ task, files, totalSize });
-    } catch (err) {
-      console.error(err);
-      message.error("文件上传失败，请稍后重试");
-      removeTask({
-        ...task,
-        isCancel: true,
-        ...taskListRef.current.find((item) => item.key === task.key),
-      });
-    }
-  };
-
-  return {
-    taskList,
-    createTask,
-    removeTask,
-    handleUpload,
-  };
-}
+import { TaskItem } from "@/pages/DataManagement/dataset.model";
+import { calculateSHA256, checkIsFilesExist, streamSplitAndUpload, StreamUploadResult } from "@/utils/file.util";
+import { App } from "antd";
+import { useRef, useState } from "react";
+
+export function useFileSliceUpload(
+  {
+    preUpload,
+    uploadChunk,
+    cancelUpload,
+  }: {
+    preUpload: (id: string, params: Record<string, unknown>) => Promise<{ data: number }>;
+    uploadChunk: (id: string, formData: FormData, config: Record<string, unknown>) => Promise<unknown>;
+    cancelUpload: ((reqId: number) => Promise<unknown>) | null;
+  },
+  showTaskCenter = true, // 上传时是否显示任务中心
+  enableStreamUpload = true // 是否启用流式分割上传
+) {
+  const { message } = App.useApp();
+  const [taskList, setTaskList] = useState<TaskItem[]>([]);
+  const taskListRef = useRef<TaskItem[]>([]); // 用于固定任务顺序
+
+  const createTask = (detail: Record<string, unknown> = {}) => {
+    const { dataset } = detail;
+    const title = `上传数据集: ${dataset.name} `;
+    const controller = new AbortController();
+    const task: TaskItem = {
+      key: dataset.id,
+      title,
+      percent: 0,
+      reqId: -1,
+      controller,
+      size: 0,
+      updateEvent: detail.updateEvent,
+      hasArchive: detail.hasArchive,
+      prefix: detail.prefix,
+    };
+    taskListRef.current = [task, ...taskListRef.current];
+
+    setTaskList(taskListRef.current);
+    
+    // 立即显示任务中心，让用户感知上传已开始
+    if (showTaskCenter) {
+      window.dispatchEvent(
+        new CustomEvent("show:task-popover", { detail: { show: true } })
+      );
+    }
+    
+    return task;
+  };
+
+  const updateTaskList = (task: TaskItem) => {
+    taskListRef.current = taskListRef.current.map((item) =>
+      item.key === task.key ? task : item
+    );
+    setTaskList(taskListRef.current);
+  };
+
+  const removeTask = (task: TaskItem) => {
+    const { key } = task;
+    taskListRef.current = taskListRef.current.filter(
+      (item) => item.key !== key
+    );
+    setTaskList(taskListRef.current);
+    if (task.isCancel && task.cancelFn) {
+      task.cancelFn();
+    }
+    if (task.updateEvent) {
+      // 携带前缀信息，便于刷新后仍停留在当前目录
+      window.dispatchEvent(
+        new CustomEvent(task.updateEvent, {
+          detail: { prefix: task.prefix },
+        })
+      );
+    }
+    if (showTaskCenter) {
+      window.dispatchEvent(
+        new CustomEvent("show:task-popover", { detail: { show: false } })
+      );
+    }
+  };
+
+  async function buildFormData({ file, reqId, i, j }: { file: { slices: Blob[]; name: string; size: number }; reqId: number; i: number; j: number }) {
+    const formData = new FormData();
+    const { slices, name, size } = file;
+    const checkSum = await calculateSHA256(slices[j]);
+    formData.append("file", slices[j]);
+    formData.append("reqId", reqId.toString());
+    formData.append("fileNo", (i + 1).toString());
+    formData.append("chunkNo", (j + 1).toString());
+    formData.append("fileName", name);
+    formData.append("fileSize", size.toString());
+    formData.append("totalChunkNum", slices.length.toString());
+    formData.append("checkSumHex", checkSum);
+    return formData;
+  }
+
+  async function uploadSlice(task: TaskItem, fileInfo: { loaded: number; i: number; j: number; files: { slices: Blob[]; name: string; size: number }[]; totalSize: number }) {
+    if (!task) {
+      return;
+    }
+    const { reqId, key, controller } = task;
+    const { loaded, i, j, files, totalSize } = fileInfo;
+    
+    // 检查是否已取消
+    if (controller.signal.aborted) {
+      throw new Error("Upload cancelled");
+    }
+    
+    const formData = await buildFormData({
+      file: files[i],
+      i,
+      j,
+      reqId,
+    });
+
+    let newTask = { ...task };
+    await uploadChunk(key, formData, {
+      signal: controller.signal,
+      onUploadProgress: (e) => {
+        const loadedSize = loaded + e.loaded;
+        const curPercent = Number((loadedSize / totalSize) * 100).toFixed(2);
+
+        newTask = {
+          ...newTask,
+          ...taskListRef.current.find((item) => item.key === key),
+          size: loadedSize,
+          percent: curPercent >= 100 ? 99.99 : curPercent,
+        };
+        updateTaskList(newTask);
+      },
+    });
+  }
+
+  async function uploadFile({ task, files, totalSize }: { task: TaskItem; files: { slices: Blob[]; name: string; size: number; originFile: Blob }[]; totalSize: number }) {
+    console.log('[useSliceUpload] Calling preUpload with prefix:', task.prefix);
+    const { data: reqId } = await preUpload(task.key, {
+      totalFileNum: files.length,
+      totalSize,
+      datasetId: task.key,
+      hasArchive: task.hasArchive,
+      prefix: task.prefix,
+    });
+    console.log('[useSliceUpload] PreUpload response reqId:', reqId);
+
+    const newTask: TaskItem = {
+      ...task,
+      reqId,
+      isCancel: false,
+      cancelFn: () => {
+        // 使用 newTask 的 controller 确保一致性
+        newTask.controller.abort();
+        cancelUpload?.(reqId);
+        if (newTask.updateEvent) window.dispatchEvent(new Event(newTask.updateEvent));
+      },
+    };
+    updateTaskList(newTask);
+    // 注意：show:task-popover 事件已在 createTask 中触发，此处不再重复触发
+    // // 更新数据状态
+    if (task.updateEvent) window.dispatchEvent(new Event(task.updateEvent));
+
+    let loaded = 0;
+    for (let i = 0; i < files.length; i++) {
+      // 检查是否已取消
+      if (newTask.controller.signal.aborted) {
+        throw new Error("Upload cancelled");
+      }
+      const { slices } = files[i];
+      for (let j = 0; j < slices.length; j++) {
+        // 检查是否已取消
+        if (newTask.controller.signal.aborted) {
+          throw new Error("Upload cancelled");
+        }
+        await uploadSlice(newTask, {
+          loaded,
+          i,
+          j,
+          files,
+          totalSize,
+        });
+        loaded += slices[j].size;
+      }
+    }
+    removeTask(newTask);
+  }
+
+  const handleUpload = async ({ task, files }: { task: TaskItem; files: { slices: Blob[]; name: string; size: number; originFile: Blob }[] }) => {
+    const isErrorFile = await checkIsFilesExist(files);
+    if (isErrorFile) {
+      message.error("文件被修改或删除，请重新选择文件上传");
+      removeTask({
+        ...task,
+        isCancel: false,
+        ...taskListRef.current.find((item) => item.key === task.key),
+      });
+      return;
+    }
+
+    try {
+      const totalSize = files.reduce((acc, file) => acc + file.size, 0);
+      await uploadFile({ task, files, totalSize });
+    } catch (err) {
+      console.error(err);
+      message.error("文件上传失败，请稍后重试");
+      removeTask({
+        ...task,
+        isCancel: true,
+        ...taskListRef.current.find((item) => item.key === task.key),
+      });
+    }
+  };
+
+  /**
+   * 流式分割上传处理
+   * 用于大文件按行分割并立即上传的场景
+   */
+  const handleStreamUpload = async ({ task, files }: { task: TaskItem; files: File[] }) => {
+    try {
+      console.log('[useSliceUpload] Starting stream upload for', files.length, 'files');
+      
+      const totalSize = files.reduce((acc, file) => acc + file.size, 0);
+      
+      // 存储所有文件的 reqId，用于取消上传
+      const reqIds: number[] = [];
+      
+      const newTask: TaskItem = {
+        ...task,
+        reqId: -1,
+        isCancel: false,
+        cancelFn: () => {
+          // 使用 newTask 的 controller 确保一致性
+          newTask.controller.abort();
+          // 取消所有文件的预上传请求
+          reqIds.forEach(id => cancelUpload?.(id));
+          if (newTask.updateEvent) window.dispatchEvent(new Event(newTask.updateEvent));
+        },
+      };
+      updateTaskList(newTask);
+
+      let totalUploadedLines = 0;
+      let totalProcessedBytes = 0;
+      const results: StreamUploadResult[] = [];
+
+      // 逐个处理文件，每个文件单独调用 preUpload
+      for (let i = 0; i < files.length; i++) {
+        // 检查是否已取消
+        if (newTask.controller.signal.aborted) {
+          throw new Error("Upload cancelled");
+        }
+        
+        const file = files[i];
+        console.log(`[useSliceUpload] Processing file ${i + 1}/${files.length}: ${file.name}`);
+        
+        const result = await streamSplitAndUpload(
+          file,
+          (formData, config) => uploadChunk(task.key, formData, {
+            ...config,
+            signal: newTask.controller.signal,
+          }),
+          (currentBytes, totalBytes, uploadedLines) => {
+            // 检查是否已取消
+            if (newTask.controller.signal.aborted) {
+              return;
+            }
+            
+            // 更新进度
+            const overallBytes = totalProcessedBytes + currentBytes;
+            const curPercent = Number((overallBytes / totalSize) * 100).toFixed(2);
+            
+            const updatedTask: TaskItem = {
+              ...newTask,
+              ...taskListRef.current.find((item) => item.key === task.key),
+              size: overallBytes,
+              percent: curPercent >= 100 ? 99.99 : curPercent,
+              streamUploadInfo: {
+                currentFile: file.name,
+                fileIndex: i + 1,
+                totalFiles: files.length,
+                uploadedLines: totalUploadedLines + uploadedLines,
+              },
+            };
+            updateTaskList(updatedTask);
+          }, 
+          1024 * 1024, // 1MB chunk size
+          {
+            resolveReqId: async ({ totalFileNum, totalSize }) => {
+              const { data: reqId } = await preUpload(task.key, {
+                totalFileNum,
+                totalSize,
+                datasetId: task.key,
+                hasArchive: task.hasArchive,
+                prefix: task.prefix,
+              });
+              console.log(`[useSliceUpload] File ${file.name} preUpload response reqId:`, reqId);
+              reqIds.push(reqId);
+              return reqId;
+            },
+            hasArchive: newTask.hasArchive,
+            prefix: newTask.prefix,
+            signal: newTask.controller.signal,
+            maxConcurrency: 3,
+          }
+        );
+        
+        results.push(result);
+        totalUploadedLines += result.uploadedCount;
+        totalProcessedBytes += file.size;
+        
+        console.log(`[useSliceUpload] File ${file.name} processed, uploaded ${result.uploadedCount} lines`);
+      }
+
+      console.log('[useSliceUpload] Stream upload completed, total lines:', totalUploadedLines);
+      removeTask(newTask);
+      
+      message.success(`成功上传 ${totalUploadedLines} 个文件（按行分割）`);
+    } catch (err) {
+      console.error('[useSliceUpload] Stream upload error:', err);
+      if (err.message === "Upload cancelled") {
+        message.info("上传已取消");
+      } else {
+        message.error("文件上传失败，请稍后重试");
+      }
+      removeTask({
+        ...task,
+        isCancel: true,
+        ...taskListRef.current.find((item) => item.key === task.key),
+      });
+    }
+  };
+
+  /**
+   * 注册流式上传事件监听
+   * 返回注销函数
+   */
+  const registerStreamUploadListener = () => {
+    if (!enableStreamUpload) return () => {};
+
+    const streamUploadHandler = async (e: Event) => {
+      const customEvent = e as CustomEvent;
+      const { dataset, files, updateEvent, hasArchive, prefix } = customEvent.detail;
+      
+      const controller = new AbortController();
+      const task: TaskItem = {
+        key: dataset.id,
+        title: `上传数据集: ${dataset.name} (按行分割)`,
+        percent: 0,
+        reqId: -1,
+        controller,
+        size: 0,
+        updateEvent,
+        hasArchive,
+        prefix,
+      };
+      
+      taskListRef.current = [task, ...taskListRef.current];
+      setTaskList(taskListRef.current);
+      
+      // 显示任务中心
+      if (showTaskCenter) {
+        window.dispatchEvent(
+          new CustomEvent("show:task-popover", { detail: { show: true } })
+        );
+      }
+      
+      await handleStreamUpload({ task, files });
+    };
+
+    window.addEventListener("upload:dataset-stream", streamUploadHandler);
+    
+    return () => {
+      window.removeEventListener("upload:dataset-stream", streamUploadHandler);
+    };
+  };
+
+  return {
+    taskList,
+    createTask,
+    removeTask,
+    handleUpload,
+    handleStreamUpload,
+    registerStreamUploadListener,
+  };
+}
--- a/frontend/src/pages/DataAnnotation/Annotate/LabelStudioTextEditor.tsx
+++ b/frontend/src/pages/DataAnnotation/Annotate/LabelStudioTextEditor.tsx
@@ -6,6 +6,7 @@ import { useNavigate, useParams } from "react-router";
 import {
  getEditorProjectInfoUsingGet,
  getEditorTaskUsingGet,
+  getEditorTaskSegmentsUsingGet,
  listEditorTasksUsingGet,
  upsertEditorAnnotationUsingPut,
 } from "../annotation.api";
@@ -38,9 +39,6 @@ type LsfMessage = {

 type SegmentInfo = {
  idx: number;
-  text: string;
-  start: number;
-  end: number;
  hasAnnotation: boolean;
  lineIndex: number;
  chunkIndex: number;
@@ -66,10 +64,16 @@ type EditorTaskPayload = {
 type EditorTaskResponse = {
  task?: EditorTaskPayload;
  segmented?: boolean;
-  segments?: SegmentInfo[];
+  totalSegments?: number;
  currentSegmentIndex?: number;
 };

+type EditorTaskSegmentsResponse = {
+  segmented?: boolean;
+  segments?: SegmentInfo[];
+  totalSegments?: number;
+};
+
 type EditorTaskListResponse = {
  content?: EditorTaskListItem[];
  totalElements?: number;
@@ -288,6 +292,7 @@ export default function LabelStudioTextEditor() {
  const segmentStatsCacheRef = useRef<Record<string, SegmentStats>>({});
  const segmentStatsSeqRef = useRef(0);
  const segmentStatsLoadingRef = useRef<Set<string>>(new Set());
+  const segmentSummaryFileRef = useRef<string>("");

  const [loadingProject, setLoadingProject] = useState(true);
  const [loadingTasks, setLoadingTasks] = useState(false);
@@ -358,9 +363,7 @@ export default function LabelStudioTextEditor() {
    if (segmentStatsCacheRef.current[fileId] || segmentStatsLoadingRef.current.has(fileId)) return;
    segmentStatsLoadingRef.current.add(fileId);
    try {
-      const resp = (await getEditorTaskUsingGet(projectId, fileId, {
-        segmentIndex: 0,
-      })) as ApiResponse<EditorTaskResponse>;
+      const resp = (await getEditorTaskSegmentsUsingGet(projectId, fileId)) as ApiResponse<EditorTaskSegmentsResponse>;
      if (segmentStatsSeqRef.current !== seq) return;
      const data = resp?.data;
      if (!data?.segmented) return;
@@ -591,20 +594,38 @@ export default function LabelStudioTextEditor() {
      if (seq !== initSeqRef.current) return;

      // 更新分段状态
-      const segmentIndex = data?.segmented
+      const isSegmented = !!data?.segmented;
+      const segmentIndex = isSegmented
        ? resolveSegmentIndex(data.currentSegmentIndex) ?? 0
        : undefined;
-      if (data?.segmented) {
-        const stats = buildSegmentStats(data.segments);
+      if (isSegmented) {
+        let nextSegments: SegmentInfo[] = [];
+        if (segmentSummaryFileRef.current === fileId && segments.length > 0) {
+          nextSegments = segments;
+        } else {
+          try {
+            const segmentResp = (await getEditorTaskSegmentsUsingGet(projectId, fileId)) as ApiResponse<EditorTaskSegmentsResponse>;
+            if (seq !== initSeqRef.current) return;
+            const segmentData = segmentResp?.data;
+            if (segmentData?.segmented) {
+              nextSegments = Array.isArray(segmentData.segments) ? segmentData.segments : [];
+            }
+          } catch (e) {
+            console.error(e);
+          }
+        }
+        const stats = buildSegmentStats(nextSegments);
        setSegmented(true);
-        setSegments(data.segments || []);
+        setSegments(nextSegments);
        setCurrentSegmentIndex(segmentIndex ?? 0);
        updateSegmentStatsCache(fileId, stats);
+        segmentSummaryFileRef.current = fileId;
      } else {
        setSegmented(false);
        setSegments([]);
        setCurrentSegmentIndex(0);
        updateSegmentStatsCache(fileId, null);
+        segmentSummaryFileRef.current = fileId;
      }

      const taskData = {
@@ -664,7 +685,7 @@ export default function LabelStudioTextEditor() {
    } finally {
      if (seq === initSeqRef.current) setLoadingTaskDetail(false);
    }
-  }, [iframeReady, message, postToIframe, project, projectId, updateSegmentStatsCache]);
+  }, [iframeReady, message, postToIframe, project, projectId, segments, updateSegmentStatsCache]);

  const advanceAfterSave = useCallback(async (fileId: string, segmentIndex?: number) => {
    if (!fileId) return;
@@ -979,6 +1000,7 @@ export default function LabelStudioTextEditor() {
    setSegmented(false);
    setSegments([]);
    setCurrentSegmentIndex(0);
+    segmentSummaryFileRef.current = "";
    savedSnapshotsRef.current = {};
    segmentStatsSeqRef.current += 1;
    segmentStatsCacheRef.current = {};
--- a/frontend/src/pages/DataAnnotation/annotation.api.ts
+++ b/frontend/src/pages/DataAnnotation/annotation.api.ts
@@ -1,20 +1,23 @@
 import { get, post, put, del, download } from "@/utils/request";

-// 导出格式类型
-export type ExportFormat = "json" | "jsonl" | "csv" | "coco" | "yolo";
-
-// 标注任务管理相关接口
-export function queryAnnotationTasksUsingGet(params?: any) {
-  return get("/api/annotation/project", params);
-}
-
-export function createAnnotationTaskUsingPost(data: any) {
-  return post("/api/annotation/project", data);
-}
-
-export function syncAnnotationTaskUsingPost(data: any) {
-  return post(`/api/annotation/task/sync`, data);
-}
+// 导出格式类型
+export type ExportFormat = "json" | "jsonl" | "csv" | "coco" | "yolo";
+
+type RequestParams = Record<string, unknown>;
+type RequestPayload = Record<string, unknown>;
+
+// 标注任务管理相关接口
+export function queryAnnotationTasksUsingGet(params?: RequestParams) {
+  return get("/api/annotation/project", params);
+}
+
+export function createAnnotationTaskUsingPost(data: RequestPayload) {
+  return post("/api/annotation/project", data);
+}
+
+export function syncAnnotationTaskUsingPost(data: RequestPayload) {
+  return post(`/api/annotation/task/sync`, data);
+}

 export function deleteAnnotationTaskByIdUsingDelete(mappingId: string) {
  // Backend expects mapping UUID as path parameter
@@ -25,9 +28,9 @@ export function getAnnotationTaskByIdUsingGet(taskId: string) {
  return get(`/api/annotation/project/${taskId}`);
 }

-export function updateAnnotationTaskByIdUsingPut(taskId: string, data: any) {
-  return put(`/api/annotation/project/${taskId}`, data);
-}
+export function updateAnnotationTaskByIdUsingPut(taskId: string, data: RequestPayload) {
+  return put(`/api/annotation/project/${taskId}`, data);
+}

 // 标签配置管理
 export function getTagConfigUsingGet() {
@@ -35,20 +38,20 @@ export function getTagConfigUsingGet() {
 }

 // 标注模板管理
-export function queryAnnotationTemplatesUsingGet(params?: any) {
-  return get("/api/annotation/template", params);
-}
+export function queryAnnotationTemplatesUsingGet(params?: RequestParams) {
+  return get("/api/annotation/template", params);
+}
+
+export function createAnnotationTemplateUsingPost(data: RequestPayload) {
+  return post("/api/annotation/template", data);
+}

-export function createAnnotationTemplateUsingPost(data: any) {
-  return post("/api/annotation/template", data);
-}
-
-export function updateAnnotationTemplateByIdUsingPut(
-  templateId: string | number,
-  data: any
-) {
-  return put(`/api/annotation/template/${templateId}`, data);
-}
+export function updateAnnotationTemplateByIdUsingPut(
+  templateId: string | number,
+  data: RequestPayload
+) {
+  return put(`/api/annotation/template/${templateId}`, data);
+}

 export function deleteAnnotationTemplateByIdUsingDelete(
  templateId: string | number
@@ -65,27 +68,31 @@ export function getEditorProjectInfoUsingGet(projectId: string) {
  return get(`/api/annotation/editor/projects/${projectId}`);
 }

-export function listEditorTasksUsingGet(projectId: string, params?: any) {
-  return get(`/api/annotation/editor/projects/${projectId}/tasks`, params);
-}
+export function listEditorTasksUsingGet(projectId: string, params?: RequestParams) {
+  return get(`/api/annotation/editor/projects/${projectId}/tasks`, params);
+}

-export function getEditorTaskUsingGet(
-  projectId: string,
-  fileId: string,
-  params?: { segmentIndex?: number }
-) {
-  return get(`/api/annotation/editor/projects/${projectId}/tasks/${fileId}`, params);
-}
+export function getEditorTaskUsingGet(
+  projectId: string,
+  fileId: string,
+  params?: { segmentIndex?: number }
+) {
+  return get(`/api/annotation/editor/projects/${projectId}/tasks/${fileId}`, params);
+}
+
+export function getEditorTaskSegmentsUsingGet(projectId: string, fileId: string) {
+  return get(`/api/annotation/editor/projects/${projectId}/tasks/${fileId}/segments`);
+}

 export function upsertEditorAnnotationUsingPut(
-  projectId: string,
-  fileId: string,
-  data: {
-    annotation: any;
-    expectedUpdatedAt?: string;
-    segmentIndex?: number;
-  }
-) {
+  projectId: string,
+  fileId: string,
+  data: {
+    annotation: Record<string, unknown>;
+    expectedUpdatedAt?: string;
+    segmentIndex?: number;
+  }
+) {
  return put(`/api/annotation/editor/projects/${projectId}/tasks/${fileId}/annotation`, data);
 }

--- a/frontend/src/pages/DataManagement/Detail/components/ImportConfiguration.tsx
+++ b/frontend/src/pages/DataManagement/Detail/components/ImportConfiguration.tsx
@@ -1,13 +1,13 @@
-import { Select, Input, Form, Radio, Modal, Button, UploadFile, Switch, Tooltip } from "antd";
-import { InboxOutlined, QuestionCircleOutlined } from "@ant-design/icons";
-import { dataSourceOptions } from "../../dataset.const";
+import { Select, Input, Form, Radio, Modal, Button, UploadFile, Switch, Tooltip } from "antd";
+import { InboxOutlined, QuestionCircleOutlined } from "@ant-design/icons";
+import { dataSourceOptions } from "../../dataset.const";
 import { Dataset, DatasetType, DataSource } from "../../dataset.model";
 import { useCallback, useEffect, useMemo, useState } from "react";
-import { queryTasksUsingGet } from "@/pages/DataCollection/collection.apis";
-import { updateDatasetByIdUsingPut } from "../../dataset.api";
-import { sliceFile } from "@/utils/file.util";
-import Dragger from "antd/es/upload/Dragger";
-
+import { queryTasksUsingGet } from "@/pages/DataCollection/collection.apis";
+import { updateDatasetByIdUsingPut } from "../../dataset.api";
+import { sliceFile, shouldStreamUpload } from "@/utils/file.util";
+import Dragger from "antd/es/upload/Dragger";
+
 const TEXT_FILE_MIME_PREFIX = "text/";
 const TEXT_FILE_MIME_TYPES = new Set([
  "application/json",
@@ -90,14 +90,16 @@ async function splitFileByLines(file: UploadFile): Promise<UploadFile[]> {
  const lines = text.split(/\r?\n/).filter((line: string) => line.trim() !== "");
  if (lines.length === 0) return [];

-  // 生成文件名：原文件名_序号.扩展名
+  // 生成文件名：原文件名_序号（不保留后缀）
  const nameParts = file.name.split(".");
-  const ext = nameParts.length > 1 ? "." + nameParts.pop() : "";
+  if (nameParts.length > 1) {
+    nameParts.pop();
+  }
  const baseName = nameParts.join(".");
  const padLength = String(lines.length).length;

  return lines.map((line: string, index: number) => {
-    const newFileName = `${baseName}_${String(index + 1).padStart(padLength, "0")}${ext}`;
+    const newFileName = `${baseName}_${String(index + 1).padStart(padLength, "0")}`;
    const blob = new Blob([line], { type: "text/plain" });
    const newFile = new File([blob], newFileName, { type: "text/plain" });
    return {
@@ -131,18 +133,18 @@ type ImportConfig = {
 };

 export default function ImportConfiguration({
-  data,
-  open,
-  onClose,
-  updateEvent = "update:dataset",
-  prefix,
-}: {
-  data: Dataset | null;
-  open: boolean;
-  onClose: () => void;
-  updateEvent?: string;
-  prefix?: string;
-}) {
+  data,
+  open,
+  onClose,
+  updateEvent = "update:dataset",
+  prefix,
+}: {
+  data: Dataset | null;
+  open: boolean;
+  onClose: () => void;
+  updateEvent?: string;
+  prefix?: string;
+}) {
  const [form] = Form.useForm();
  const [collectionOptions, setCollectionOptions] = useState<SelectOption[]>([]);
  const availableSourceOptions = dataSourceOptions.filter(
@@ -160,23 +162,81 @@ export default function ImportConfiguration({
    return files.some((file) => !isTextUploadFile(file));
  }, [importConfig.files]);
  const isTextDataset = data?.datasetType === DatasetType.TEXT;
-
-  // 本地上传文件相关逻辑
-
-  const handleUpload = async (dataset: Dataset) => {
-    let filesToUpload =
+
+  // 本地上传文件相关逻辑
+
+  const handleUpload = async (dataset: Dataset) => {
+    const filesToUpload =
      (form.getFieldValue("files") as UploadFile[] | undefined) || [];
-
-    // 如果启用分行分割，处理文件
+
+    // 如果启用分行分割，对大文件使用流式处理
    if (importConfig.splitByLine && !hasNonTextFile) {
-      const splitResults = await Promise.all(
-        filesToUpload.map((file) => splitFileByLines(file))
-      );
-      filesToUpload = splitResults.flat();
+      // 检查是否有大文件需要流式分割上传
+      const filesForStreamUpload: File[] = [];
+      const filesForNormalUpload: UploadFile[] = [];
+
+      for (const file of filesToUpload) {
+        const originFile = file.originFileObj ?? file;
+        if (originFile instanceof File && shouldStreamUpload(originFile)) {
+          filesForStreamUpload.push(originFile);
+        } else {
+          filesForNormalUpload.push(file);
+        }
+      }
+
+      // 大文件使用流式分割上传
+      if (filesForStreamUpload.length > 0) {
+        window.dispatchEvent(
+          new CustomEvent("upload:dataset-stream", {
+            detail: {
+              dataset,
+              files: filesForStreamUpload,
+              updateEvent,
+              hasArchive: importConfig.hasArchive,
+              prefix: currentPrefix,
+            },
+          })
+        );
+      }
+
+      // 小文件使用传统分割方式
+      if (filesForNormalUpload.length > 0) {
+        const splitResults = await Promise.all(
+          filesForNormalUpload.map((file) => splitFileByLines(file))
+        );
+        const smallFilesToUpload = splitResults.flat();
+        
+        // 计算分片列表
+        const sliceList = smallFilesToUpload.map((file) => {
+          const originFile = (file.originFileObj ?? file) as Blob;
+          const slices = sliceFile(originFile);
+          return {
+            originFile: originFile,
+            slices,
+            name: file.name,
+            size: originFile.size || 0,
+          };
+        });
+
+        console.log("[ImportConfiguration] Uploading small files with currentPrefix:", currentPrefix);
+        window.dispatchEvent(
+          new CustomEvent("upload:dataset", {
+            detail: {
+              dataset,
+              files: sliceList,
+              updateEvent,
+              hasArchive: importConfig.hasArchive,
+              prefix: currentPrefix,
+            },
+          })
+        );
+      }
+      return;
    }
-
-    // 计算分片列表
-    const sliceList = filesToUpload.map((file) => {
+
+    // 未启用分行分割，使用普通上传
+    // 计算分片列表
+    const sliceList = filesToUpload.map((file) => {
      const originFile = (file.originFileObj ?? file) as Blob;
      const slices = sliceFile(originFile);
      return {
@@ -185,22 +245,22 @@ export default function ImportConfiguration({
        name: file.name,
        size: originFile.size || 0,
      };
-    });
-
-    console.log("[ImportConfiguration] Uploading with currentPrefix:", currentPrefix);
-    window.dispatchEvent(
-      new CustomEvent("upload:dataset", {
-        detail: {
-          dataset,
-          files: sliceList,
-          updateEvent,
-          hasArchive: importConfig.hasArchive,
-          prefix: currentPrefix,
-        },
-      })
-    );
-  };
-
+    });
+
+    console.log("[ImportConfiguration] Uploading with currentPrefix:", currentPrefix);
+    window.dispatchEvent(
+      new CustomEvent("upload:dataset", {
+        detail: {
+          dataset,
+          files: sliceList,
+          updateEvent,
+          hasArchive: importConfig.hasArchive,
+          prefix: currentPrefix,
+        },
+      })
+    );
+  };
+
  const fetchCollectionTasks = useCallback(async () => {
    if (importConfig.source !== DataSource.COLLECTION) return;
    try {
@@ -212,7 +272,7 @@ export default function ImportConfiguration({
        label: task.name,
        value: task.id,
      }));
-      setCollectionOptions(options);
+      setCollectionOptions(options);
    } catch (error) {
      console.error("Error fetching collection tasks:", error);
    }
@@ -229,27 +289,31 @@ export default function ImportConfiguration({
    });
    console.log('[ImportConfiguration] resetState done, currentPrefix still:', currentPrefix);
  }, [currentPrefix, form]);
-
-  const handleImportData = async () => {
-    if (!data) return;
-    console.log('[ImportConfiguration] handleImportData called, currentPrefix:', currentPrefix);
-    if (importConfig.source === DataSource.UPLOAD) {
-      await handleUpload(data);
-    } else if (importConfig.source === DataSource.COLLECTION) {
-      await updateDatasetByIdUsingPut(data.id, {
-        ...importConfig,
-      });
-    }
-    onClose();
-  };
-
+
+  const handleImportData = async () => {
+    if (!data) return;
+    console.log('[ImportConfiguration] handleImportData called, currentPrefix:', currentPrefix);
+    if (importConfig.source === DataSource.UPLOAD) {
+      // 立即显示任务中心，让用户感知上传已开始（在文件分割等耗时操作之前）
+      window.dispatchEvent(
+        new CustomEvent("show:task-popover", { detail: { show: true } })
+      );
+      await handleUpload(data);
+    } else if (importConfig.source === DataSource.COLLECTION) {
+      await updateDatasetByIdUsingPut(data.id, {
+        ...importConfig,
+      });
+    }
+    onClose();
+  };
+
  useEffect(() => {
    if (open) {
      setCurrentPrefix(prefix || "");
-      console.log('[ImportConfiguration] Modal opened with prefix:', prefix);
-      resetState();
-      fetchCollectionTasks();
-    }
+      console.log('[ImportConfiguration] Modal opened with prefix:', prefix);
+      resetState();
+      fetchCollectionTasks();
+    }
  }, [fetchCollectionTasks, open, prefix, resetState]);

  useEffect(() => {
@@ -259,111 +323,111 @@ export default function ImportConfiguration({
    form.setFieldsValue({ splitByLine: false });
    setImportConfig((prev) => ({ ...prev, splitByLine: false }));
  }, [form, hasNonTextFile, importConfig.files, importConfig.splitByLine]);
-
-  // Separate effect for fetching collection tasks when source changes
-  useEffect(() => {
-    if (open && importConfig.source === DataSource.COLLECTION) {
-      fetchCollectionTasks();
-    }
+
+  // Separate effect for fetching collection tasks when source changes
+  useEffect(() => {
+    if (open && importConfig.source === DataSource.COLLECTION) {
+      fetchCollectionTasks();
+    }
  }, [fetchCollectionTasks, importConfig.source, open]);
-
-  return (
-    <Modal
-      title="导入数据"
-      open={open}
-      width={600}
-      onCancel={() => {
-        onClose();
-        resetState();
-      }}
-      maskClosable={false}
-      footer={
-        <>
-          <Button onClick={onClose}>取消</Button>
-          <Button
-            type="primary"
-            disabled={!importConfig?.files?.length && !importConfig.dataSource}
-            onClick={handleImportData}
-          >
-            确定
-          </Button>
-        </>
-      }
-    >
-      <Form
-        form={form}
-        layout="vertical"
-        initialValues={importConfig || {}}
-        onValuesChange={(_, allValues) => setImportConfig(allValues)}
-      >
-        <Form.Item
-          label="数据源"
-          name="source"
-          rules={[{ required: true, message: "请选择数据源" }]}
-        >
+
+  return (
+    <Modal
+      title="导入数据"
+      open={open}
+      width={600}
+      onCancel={() => {
+        onClose();
+        resetState();
+      }}
+      maskClosable={false}
+      footer={
+        <>
+          <Button onClick={onClose}>取消</Button>
+          <Button
+            type="primary"
+            disabled={!importConfig?.files?.length && !importConfig.dataSource}
+            onClick={handleImportData}
+          >
+            确定
+          </Button>
+        </>
+      }
+    >
+      <Form
+        form={form}
+        layout="vertical"
+        initialValues={importConfig || {}}
+        onValuesChange={(_, allValues) => setImportConfig(allValues)}
+      >
+        <Form.Item
+          label="数据源"
+          name="source"
+          rules={[{ required: true, message: "请选择数据源" }]}
+        >
            <Radio.Group
              buttonStyle="solid"
              options={availableSourceOptions}
              optionType="button"
            />
          </Form.Item>
-        {importConfig?.source === DataSource.COLLECTION && (
-          <Form.Item name="dataSource" label="归集任务" required>
-            <Select placeholder="请选择归集任务" options={collectionOptions} />
-          </Form.Item>
-        )}
-
-        {/* obs import */}
-        {importConfig?.source === DataSource.OBS && (
-          <div className="grid grid-cols-2 gap-3 p-4 bg-blue-50 rounded-lg">
-            <Form.Item
-              name="endpoint"
-              rules={[{ required: true }]}
-              label="Endpoint"
-            >
-              <Input
-                className="h-8 text-xs"
-                placeholder="obs.cn-north-4.myhuaweicloud.com"
-              />
-            </Form.Item>
-            <Form.Item
-              name="bucket"
-              rules={[{ required: true }]}
-              label="Bucket"
-            >
-              <Input className="h-8 text-xs" placeholder="my-bucket" />
-            </Form.Item>
-            <Form.Item
-              name="accessKey"
-              rules={[{ required: true }]}
-              label="Access Key"
-            >
-              <Input className="h-8 text-xs" placeholder="Access Key" />
-            </Form.Item>
-            <Form.Item
-              name="secretKey"
-              rules={[{ required: true }]}
-              label="Secret Key"
-            >
-              <Input
-                type="password"
-                className="h-8 text-xs"
-                placeholder="Secret Key"
-              />
-            </Form.Item>
-          </div>
-        )}
-
-        {/* Local Upload Component */}
-        {importConfig?.source === DataSource.UPLOAD && (
-          <>
-            <Form.Item
-              label="自动解压上传的压缩包"
-              name="hasArchive"
-              valuePropName="checked"
-            >
-              <Switch />
-            </Form.Item>
+        {importConfig?.source === DataSource.COLLECTION && (
+          <Form.Item name="dataSource" label="归集任务" required>
+            <Select placeholder="请选择归集任务" options={collectionOptions} />
+          </Form.Item>
+        )}
+
+        {/* obs import */}
+        {importConfig?.source === DataSource.OBS && (
+          <div className="grid grid-cols-2 gap-3 p-4 bg-blue-50 rounded-lg">
+            <Form.Item
+              name="endpoint"
+              rules={[{ required: true }]}
+              label="Endpoint"
+            >
+              <Input
+                className="h-8 text-xs"
+                placeholder="obs.cn-north-4.myhuaweicloud.com"
+              />
+            </Form.Item>
+            <Form.Item
+              name="bucket"
+              rules={[{ required: true }]}
+              label="Bucket"
+            >
+              <Input className="h-8 text-xs" placeholder="my-bucket" />
+            </Form.Item>
+            <Form.Item
+              name="accessKey"
+              rules={[{ required: true }]}
+              label="Access Key"
+            >
+              <Input className="h-8 text-xs" placeholder="Access Key" />
+            </Form.Item>
+            <Form.Item
+              name="secretKey"
+              rules={[{ required: true }]}
+              label="Secret Key"
+            >
+              <Input
+                type="password"
+                className="h-8 text-xs"
+                placeholder="Secret Key"
+              />
+            </Form.Item>
+          </div>
+        )}
+
+        {/* Local Upload Component */}
+        {importConfig?.source === DataSource.UPLOAD && (
+          <>
+            <Form.Item
+              label="自动解压上传的压缩包"
+              name="hasArchive"
+              valuePropName="checked"
+            >
+              <Switch />
+            </Form.Item>
            {isTextDataset && (
              <Form.Item
                label={
@@ -386,10 +450,10 @@ export default function ImportConfiguration({
                <Switch disabled={hasNonTextFile} />
              </Form.Item>
            )}
-            <Form.Item
-              label="上传文件"
-              name="files"
-              valuePropName="fileList"
+            <Form.Item
+              label="上传文件"
+              name="files"
+              valuePropName="fileList"
              getValueFromEvent={(
                event: { fileList?: UploadFile[] } | UploadFile[]
              ) => {
@@ -398,69 +462,69 @@ export default function ImportConfiguration({
                }
                return event?.fileList;
              }}
-              rules={[
-                {
-                  required: true,
-                  message: "请上传文件",
-                },
-              ]}
-            >
-              <Dragger
-                className="w-full"
-                beforeUpload={() => false}
-                multiple
-              >
-                <p className="ant-upload-drag-icon">
-                  <InboxOutlined />
-                </p>
-                <p className="ant-upload-text">本地文件上传</p>
-                <p className="ant-upload-hint">拖拽文件到此处或点击选择文件</p>
-              </Dragger>
-            </Form.Item>
-          </>
-        )}
-
-        {/* Target Configuration */}
-        {importConfig?.target && importConfig?.target !== DataSource.UPLOAD && (
-          <div className="space-y-3 p-4 bg-blue-50 rounded-lg">
-            {importConfig?.target === DataSource.DATABASE && (
-              <div className="grid grid-cols-2 gap-3">
-                <Form.Item
-                  name="databaseType"
-                  rules={[{ required: true }]}
-                  label="数据库类型"
-                >
-                  <Select
-                    className="w-full"
-                    options={[
-                      { label: "MySQL", value: "mysql" },
-                      { label: "PostgreSQL", value: "postgresql" },
-                      { label: "MongoDB", value: "mongodb" },
-                    ]}
-                  ></Select>
-                </Form.Item>
-                <Form.Item
-                  name="tableName"
-                  rules={[{ required: true }]}
-                  label="表名"
-                >
-                  <Input className="h-8 text-xs" placeholder="dataset_table" />
-                </Form.Item>
-                <Form.Item
-                  name="connectionString"
-                  rules={[{ required: true }]}
-                  label="连接字符串"
-                >
-                  <Input
-                    className="h-8 text-xs col-span-2"
-                    placeholder="数据库连接字符串"
-                  />
-                </Form.Item>
-              </div>
-            )}
-          </div>
-        )}
-      </Form>
-    </Modal>
-  );
-}
+              rules={[
+                {
+                  required: true,
+                  message: "请上传文件",
+                },
+              ]}
+            >
+              <Dragger
+                className="w-full"
+                beforeUpload={() => false}
+                multiple
+              >
+                <p className="ant-upload-drag-icon">
+                  <InboxOutlined />
+                </p>
+                <p className="ant-upload-text">本地文件上传</p>
+                <p className="ant-upload-hint">拖拽文件到此处或点击选择文件</p>
+              </Dragger>
+            </Form.Item>
+          </>
+        )}
+
+        {/* Target Configuration */}
+        {importConfig?.target && importConfig?.target !== DataSource.UPLOAD && (
+          <div className="space-y-3 p-4 bg-blue-50 rounded-lg">
+            {importConfig?.target === DataSource.DATABASE && (
+              <div className="grid grid-cols-2 gap-3">
+                <Form.Item
+                  name="databaseType"
+                  rules={[{ required: true }]}
+                  label="数据库类型"
+                >
+                  <Select
+                    className="w-full"
+                    options={[
+                      { label: "MySQL", value: "mysql" },
+                      { label: "PostgreSQL", value: "postgresql" },
+                      { label: "MongoDB", value: "mongodb" },
+                    ]}
+                  ></Select>
+                </Form.Item>
+                <Form.Item
+                  name="tableName"
+                  rules={[{ required: true }]}
+                  label="表名"
+                >
+                  <Input className="h-8 text-xs" placeholder="dataset_table" />
+                </Form.Item>
+                <Form.Item
+                  name="connectionString"
+                  rules={[{ required: true }]}
+                  label="连接字符串"
+                >
+                  <Input
+                    className="h-8 text-xs col-span-2"
+                    placeholder="数据库连接字符串"
+                  />
+                </Form.Item>
+              </div>
+            )}
+          </div>
+        )}
+      </Form>
+    </Modal>
+  );
+}
--- a/frontend/src/pages/DataManagement/dataset.model.ts
+++ b/frontend/src/pages/DataManagement/dataset.model.ts
@@ -102,6 +102,13 @@ export interface DatasetTask {
  executionHistory?: { time: string; status: string }[];
 }

+export interface StreamUploadInfo {
+  currentFile: string;
+  fileIndex: number;
+  totalFiles: number;
+  uploadedLines: number;
+}
+
 export interface TaskItem {
  key: string;
  title: string;
@@ -113,4 +120,6 @@ export interface TaskItem {
  updateEvent?: string;
  size?: number;
  hasArchive?: boolean;
+  prefix?: string;
+  streamUploadInfo?: StreamUploadInfo;
 }
--- a/frontend/src/pages/Layout/TaskUpload.tsx
+++ b/frontend/src/pages/Layout/TaskUpload.tsx
@@ -1,69 +1,93 @@
-import {
-  cancelUploadUsingPut,
-  preUploadUsingPost,
-  uploadFileChunkUsingPost,
-} from "@/pages/DataManagement/dataset.api";
-import { Button, Empty, Progress } from "antd";
-import { DeleteOutlined } from "@ant-design/icons";
-import { useEffect } from "react";
-import { useFileSliceUpload } from "@/hooks/useSliceUpload";
-
-export default function TaskUpload() {
-  const { createTask, taskList, removeTask, handleUpload } = useFileSliceUpload(
-    {
-      preUpload: preUploadUsingPost,
-      uploadChunk: uploadFileChunkUsingPost,
-      cancelUpload: cancelUploadUsingPut,
-    }
-  );
-
-  useEffect(() => {
-    const uploadHandler = (e: any) => {
-      console.log('[TaskUpload] Received upload event detail:', e.detail);
-      const { files } = e.detail;
-      const task = createTask(e.detail);
-      console.log('[TaskUpload] Created task with prefix:', task.prefix);
-      handleUpload({ task, files });
-    };
-    window.addEventListener("upload:dataset", uploadHandler);
-    return () => {
-      window.removeEventListener("upload:dataset", uploadHandler);
-    };
-  }, []);
-
-  return (
-    <div
-      className="w-90 max-w-90 max-h-96 overflow-y-auto p-2"
-      id="header-task-popover"
-    >
-      {taskList.length > 0 &&
-        taskList.map((task) => (
-          <div key={task.key} className="border-b border-gray-200 pb-2">
-            <div className="flex items-center justify-between">
-              <div>{task.title}</div>
-              <Button
-                type="text"
-                danger
-                disabled={!task?.cancelFn}
-                onClick={() =>
-                  removeTask({
-                    ...task,
-                    isCancel: true,
-                  })
-                }
-                icon={<DeleteOutlined />}
-              ></Button>
-            </div>
-
-            <Progress size="small" percent={task.percent} />
-          </div>
-        ))}
-      {taskList.length === 0 && (
-        <Empty
-          image={Empty.PRESENTED_IMAGE_SIMPLE}
-          description="暂无上传任务"
-        />
-      )}
-    </div>
-  );
-}
+import {
+  cancelUploadUsingPut,
+  preUploadUsingPost,
+  uploadFileChunkUsingPost,
+} from "@/pages/DataManagement/dataset.api";
+import { Button, Empty, Progress, Tag } from "antd";
+import { DeleteOutlined, FileTextOutlined } from "@ant-design/icons";
+import { useEffect } from "react";
+import { useFileSliceUpload } from "@/hooks/useSliceUpload";
+
+export default function TaskUpload() {
+  const { createTask, taskList, removeTask, handleUpload, registerStreamUploadListener } = useFileSliceUpload(
+    {
+      preUpload: preUploadUsingPost,
+      uploadChunk: uploadFileChunkUsingPost,
+      cancelUpload: cancelUploadUsingPut,
+    },
+    true, // showTaskCenter
+    true  // enableStreamUpload
+  );
+
+  useEffect(() => {
+    const uploadHandler = (e: Event) => {
+      const customEvent = e as CustomEvent;
+      console.log('[TaskUpload] Received upload event detail:', customEvent.detail);
+      const { files } = customEvent.detail;
+      const task = createTask(customEvent.detail);
+      console.log('[TaskUpload] Created task with prefix:', task.prefix);
+      handleUpload({ task, files });
+    };
+    window.addEventListener("upload:dataset", uploadHandler);
+    return () => {
+      window.removeEventListener("upload:dataset", uploadHandler);
+    };
+  }, [createTask, handleUpload]);
+
+  // 注册流式上传监听器
+  useEffect(() => {
+    const unregister = registerStreamUploadListener();
+    return unregister;
+  }, [registerStreamUploadListener]);
+
+  return (
+    <div
+      className="w-90 max-w-90 max-h-96 overflow-y-auto p-2"
+      id="header-task-popover"
+    >
+      {taskList.length > 0 &&
+        taskList.map((task) => (
+          <div key={task.key} className="border-b border-gray-200 pb-2">
+            <div className="flex items-center justify-between">
+              <div>{task.title}</div>
+              <Button
+                type="text"
+                danger
+                disabled={!task?.cancelFn}
+                onClick={() =>
+                  removeTask({
+                    ...task,
+                    isCancel: true,
+                  })
+                }
+                icon={<DeleteOutlined />}
+              ></Button>
+            </div>
+
+            <Progress size="small" percent={Number(task.percent)} />
+            {task.streamUploadInfo && (
+              <div className="flex items-center gap-2 text-xs text-gray-500 mt-1">
+                <Tag icon={<FileTextOutlined />} size="small">
+                  按行分割
+                </Tag>
+                <span>
+                  已上传: {task.streamUploadInfo.uploadedLines} 行
+                </span>
+                {task.streamUploadInfo.totalFiles > 1 && (
+                  <span>
+                    ({task.streamUploadInfo.fileIndex}/{task.streamUploadInfo.totalFiles} 文件)
+                  </span>
+                )}
+              </div>
+            )}
+          </div>
+        ))}
+      {taskList.length === 0 && (
+        <Empty
+          image={Empty.PRESENTED_IMAGE_SIMPLE}
+          description="暂无上传任务"
+        />
+      )}
+    </div>
+  );
+}
--- a/frontend/src/utils/file.util.ts
+++ b/frontend/src/utils/file.util.ts
@@ -1,79 +1,657 @@
 import { UploadFile } from "antd";
 import jsSHA from "jssha";

-const CHUNK_SIZE = 1024 * 1024 * 60;
+// 默认分片大小：5MB（适合大多数网络环境）
+export const DEFAULT_CHUNK_SIZE = 1024 * 1024 * 5;
+// 大文件阈值：10MB
+export const LARGE_FILE_THRESHOLD = 1024 * 1024 * 10;
+// 最大并发上传数
+export const MAX_CONCURRENT_UPLOADS = 3;
+// 文本文件读取块大小：20MB（用于计算 SHA256）
+const BUFFER_CHUNK_SIZE = 1024 * 1024 * 20;

-export function sliceFile(file, chunkSize = CHUNK_SIZE): Blob[] {
+/**
+ * 将文件分割为多个分片
+ * @param file 文件对象
+ * @param chunkSize 分片大小（字节），默认 5MB
+ * @returns 分片数组（Blob 列表）
+ */
+export function sliceFile(file: Blob, chunkSize = DEFAULT_CHUNK_SIZE): Blob[] {
  const totalSize = file.size;
+  const chunks: Blob[] = [];
+  
+  // 小文件不需要分片
+  if (totalSize <= chunkSize) {
+    return [file];
+  }
+  
  let start = 0;
-  let end = start + chunkSize;
-  const chunks = [];
  while (start < totalSize) {
+    const end = Math.min(start + chunkSize, totalSize);
    const blob = file.slice(start, end);
    chunks.push(blob);
-
    start = end;
-    end = start + chunkSize;
  }
+  
  return chunks;
 }

-export function calculateSHA256(file: Blob): Promise<string> {
-  let count = 0;
-  const hash = new jsSHA("SHA-256", "ARRAYBUFFER", { encoding: "UTF8" });
+/**
+ * 计算文件的 SHA256 哈希值
+ * @param file 文件 Blob
+ * @param onProgress 进度回调（可选）
+ * @returns SHA256 哈希字符串
+ */
+export function calculateSHA256(
+  file: Blob, 
+  onProgress?: (percent: number) => void
+): Promise<string> {
  return new Promise((resolve, reject) => {
+    const hash = new jsSHA("SHA-256", "ARRAYBUFFER", { encoding: "UTF8" });
    const reader = new FileReader();
+    let processedSize = 0;

    function readChunk(start: number, end: number) {
      const slice = file.slice(start, end);
      reader.readAsArrayBuffer(slice);
    }

-    const bufferChunkSize = 1024 * 1024 * 20;
-
    function processChunk(offset: number) {
      const start = offset;
-      const end = Math.min(start + bufferChunkSize, file.size);
-      count = end;
-
+      const end = Math.min(start + BUFFER_CHUNK_SIZE, file.size);
      readChunk(start, end);
    }

-    reader.onloadend = function () {
-      const arraybuffer = reader.result;
+    reader.onloadend = function (e) {
+      const arraybuffer = reader.result as ArrayBuffer;
+      if (!arraybuffer) {
+        reject(new Error("Failed to read file"));
+        return;
+      }

      hash.update(arraybuffer);
-      if (count < file.size) {
-        processChunk(count);
+      processedSize += (e.target as FileReader).result?.byteLength || 0;
+      
+      if (onProgress) {
+        const percent = Math.min(100, Math.round((processedSize / file.size) * 100));
+        onProgress(percent);
+      }
+      
+      if (processedSize < file.size) {
+        processChunk(processedSize);
      } else {
        resolve(hash.getHash("HEX", { outputLen: 256 }));
      }
    };

+    reader.onerror = () => reject(new Error("File reading failed"));
    processChunk(0);
  });
 }

+/**
+ * 批量计算多个文件的 SHA256
+ * @param files 文件列表
+ * @param onFileProgress 单个文件进度回调（可选）
+ * @returns 哈希值数组
+ */
+export async function calculateSHA256Batch(
+  files: Blob[],
+  onFileProgress?: (index: number, percent: number) => void
+): Promise<string[]> {
+  const results: string[] = [];
+  
+  for (let i = 0; i < files.length; i++) {
+    const hash = await calculateSHA256(files[i], (percent) => {
+      onFileProgress?.(i, percent);
+    });
+    results.push(hash);
+  }
+  
+  return results;
+}
+
+/**
+ * 检查文件是否存在（未被修改或删除）
+ * @param fileList 文件列表
+ * @returns 返回第一个不存在的文件，或 null（如果都存在）
+ */
 export function checkIsFilesExist(
-  fileList: UploadFile[]
-): Promise<UploadFile | null> {
+  fileList: Array<{ originFile?: Blob }>
+): Promise<{ originFile?: Blob } | null> {
  return new Promise((resolve) => {
-    const loadEndFn = (file: UploadFile, reachEnd: boolean, e) => {
-      const fileNotExist = !e.target.result;
+    if (!fileList.length) {
+      resolve(null);
+      return;
+    }
+
+    let checkedCount = 0;
+    const totalCount = fileList.length;
+
+    const loadEndFn = (file: { originFile?: Blob }, e: ProgressEvent<FileReader>) => {
+      checkedCount++;
+      const fileNotExist = !e.target?.result;
      if (fileNotExist) {
        resolve(file);
+        return;
      }
-      if (reachEnd) {
+      if (checkedCount >= totalCount) {
        resolve(null);
      }
    };

-    for (let i = 0; i < fileList.length; i++) {
-      const { originFile: file } = fileList[i];
+    for (const file of fileList) {
      const fileReader = new FileReader();
-      fileReader.readAsArrayBuffer(file);
-      fileReader.onloadend = (e) =>
-        loadEndFn(fileList[i], i === fileList.length - 1, e);
+      const actualFile = file.originFile;
+      
+      if (!actualFile) {
+        checkedCount++;
+        if (checkedCount >= totalCount) {
+          resolve(null);
+        }
+        continue;
+      }
+      
+      fileReader.readAsArrayBuffer(actualFile.slice(0, 1));
+      fileReader.onloadend = (e) => loadEndFn(file, e);
+      fileReader.onerror = () => {
+        checkedCount++;
+        resolve(file);
+      };
    }
  });
 }
+
+/**
+ * 判断文件是否为大文件
+ * @param size 文件大小（字节）
+ * @param threshold 阈值（字节），默认 10MB
+ */
+export function isLargeFile(size: number, threshold = LARGE_FILE_THRESHOLD): boolean {
+  return size > threshold;
+}
+
+/**
+ * 格式化文件大小为人类可读格式
+ * @param bytes 字节数
+ * @param decimals 小数位数
+ */
+export function formatFileSize(bytes: number, decimals = 2): string {
+  if (bytes === 0) return "0 B";
+  
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
+}
+
+/**
+ * 并发执行异步任务
+ * @param tasks 任务函数数组
+ * @param maxConcurrency 最大并发数
+ * @param onTaskComplete 单个任务完成回调（可选）
+ */
+export async function runConcurrentTasks<T>(
+  tasks: (() => Promise<T>)[],
+  maxConcurrency: number,
+  onTaskComplete?: (index: number, result: T) => void
+): Promise<T[]> {
+  const results: T[] = new Array(tasks.length);
+  let index = 0;
+
+  async function runNext(): Promise<void> {
+    const currentIndex = index++;
+    if (currentIndex >= tasks.length) return;
+
+    const result = await tasks[currentIndex]();
+    results[currentIndex] = result;
+    onTaskComplete?.(currentIndex, result);
+    
+    await runNext();
+  }
+
+  const workers = Array(Math.min(maxConcurrency, tasks.length))
+    .fill(null)
+    .map(() => runNext());
+
+  await Promise.all(workers);
+  return results;
+}
+
+/**
+ * 按行分割文本文件内容
+ * @param text 文本内容
+ * @param skipEmptyLines 是否跳过空行，默认 true
+ * @returns 行数组
+ */
+export function splitTextByLines(text: string, skipEmptyLines = true): string[] {
+  const lines = text.split(/\r?\n/);
+  if (skipEmptyLines) {
+    return lines.filter((line) => line.trim() !== "");
+  }
+  return lines;
+}
+
+/**
+ * 创建分片信息对象
+ * @param file 原始文件
+ * @param chunkSize 分片大小
+ */
+export function createFileSliceInfo(
+  file: File | Blob,
+  chunkSize = DEFAULT_CHUNK_SIZE
+): {
+  originFile: Blob;
+  slices: Blob[];
+  name: string;
+  size: number;
+  totalChunks: number;
+} {
+  const slices = sliceFile(file, chunkSize);
+  return {
+    originFile: file,
+    slices,
+    name: (file as File).name || "unnamed",
+    size: file.size,
+    totalChunks: slices.length,
+  };
+}
+
+/**
+ * 支持的文本文件 MIME 类型前缀
+ */
+export const TEXT_FILE_MIME_PREFIX = "text/";
+
+/**
+ * 支持的文本文件 MIME 类型集合
+ */
+export const TEXT_FILE_MIME_TYPES = new Set([
+  "application/json",
+  "application/xml",
+  "application/csv",
+  "application/ndjson",
+  "application/x-ndjson",
+  "application/x-yaml",
+  "application/yaml",
+  "application/javascript",
+  "application/x-javascript",
+  "application/sql",
+  "application/rtf",
+  "application/xhtml+xml",
+  "application/svg+xml",
+]);
+
+/**
+ * 支持的文本文件扩展名集合
+ */
+export const TEXT_FILE_EXTENSIONS = new Set([
+  ".txt",
+  ".md",
+  ".markdown",
+  ".csv",
+  ".tsv",
+  ".json",
+  ".jsonl",
+  ".ndjson",
+  ".log",
+  ".xml",
+  ".yaml",
+  ".yml",
+  ".sql",
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".html",
+  ".htm",
+  ".css",
+  ".scss",
+  ".less",
+  ".py",
+  ".java",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".go",
+  ".rs",
+  ".rb",
+  ".php",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".ps1",
+  ".bat",
+  ".cmd",
+  ".svg",
+  ".rtf",
+]);
+
+/**
+ * 判断文件是否为文本文件（支持 UploadFile 类型）
+ * @param file UploadFile 对象
+ */
+export function isTextUploadFile(file: UploadFile): boolean {
+  const mimeType = (file.type || "").toLowerCase();
+  if (mimeType) {
+    if (mimeType.startsWith(TEXT_FILE_MIME_PREFIX)) return true;
+    if (TEXT_FILE_MIME_TYPES.has(mimeType)) return true;
+  }
+
+  const fileName = file.name || "";
+  const dotIndex = fileName.lastIndexOf(".");
+  if (dotIndex < 0) return false;
+  const ext = fileName.slice(dotIndex).toLowerCase();
+  return TEXT_FILE_EXTENSIONS.has(ext);
+}
+
+/**
+ * 判断文件名是否为文本文件
+ * @param fileName 文件名
+ */
+export function isTextFileByName(fileName: string): boolean {
+  const lowerName = fileName.toLowerCase();
+  
+  // 先检查 MIME 类型（如果有）
+  // 这里简化处理，主要通过扩展名判断
+  
+  const dotIndex = lowerName.lastIndexOf(".");
+  if (dotIndex < 0) return false;
+  const ext = lowerName.slice(dotIndex);
+  return TEXT_FILE_EXTENSIONS.has(ext);
+}
+
+/**
+ * 获取文件扩展名
+ * @param fileName 文件名
+ */
+export function getFileExtension(fileName: string): string {
+  const dotIndex = fileName.lastIndexOf(".");
+  if (dotIndex < 0) return "";
+  return fileName.slice(dotIndex).toLowerCase();
+}
+
+/**
+ * 安全地读取文件为文本
+ * @param file 文件对象
+ * @param encoding 编码，默认 UTF-8
+ */
+export function readFileAsText(
+  file: File | Blob,
+  encoding = "UTF-8"
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (e) => resolve(e.target?.result as string);
+    reader.onerror = () => reject(new Error("Failed to read file"));
+    reader.readAsText(file, encoding);
+  });
+}
+
+/**
+ * 流式分割文件并逐行上传
+ * 使用 Blob.slice 逐块读取，避免一次性加载大文件到内存
+ * @param file 文件对象
+ * @param datasetId 数据集ID
+ * @param uploadFn 上传函数，接收 FormData 和配置，返回 Promise
+ * @param onProgress 进度回调 (currentBytes, totalBytes, uploadedLines)
+ * @param chunkSize 每次读取的块大小，默认 1MB
+ * @param options 其他选项
+ * @returns 上传结果统计
+ */
+export interface StreamUploadOptions {
+  reqId?: number;
+  resolveReqId?: (params: { totalFileNum: number; totalSize: number }) => Promise<number>;
+  onReqIdResolved?: (reqId: number) => void;
+  fileNamePrefix?: string;
+  hasArchive?: boolean;
+  prefix?: string;
+  signal?: AbortSignal;
+  maxConcurrency?: number;
+}
+
+export interface StreamUploadResult {
+  uploadedCount: number;
+  totalBytes: number;
+  skippedEmptyCount: number;
+}
+
+async function processFileLines(
+  file: File,
+  chunkSize: number,
+  signal: AbortSignal | undefined,
+  onLine?: (line: string, index: number) => Promise<void> | void,
+  onProgress?: (currentBytes: number, totalBytes: number, processedLines: number) => void
+): Promise<{ lineCount: number; skippedEmptyCount: number }> {
+  const fileSize = file.size;
+  let offset = 0;
+  let buffer = "";
+  let skippedEmptyCount = 0;
+  let lineIndex = 0;
+
+  while (offset < fileSize) {
+    if (signal?.aborted) {
+      throw new Error("Upload cancelled");
+    }
+
+    const end = Math.min(offset + chunkSize, fileSize);
+    const chunk = file.slice(offset, end);
+    const text = await readFileAsText(chunk);
+    const combined = buffer + text;
+    const lines = combined.split(/\r?\n/);
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (signal?.aborted) {
+        throw new Error("Upload cancelled");
+      }
+      if (!line.trim()) {
+        skippedEmptyCount++;
+        continue;
+      }
+      const currentIndex = lineIndex;
+      lineIndex += 1;
+      if (onLine) {
+        await onLine(line, currentIndex);
+      }
+    }
+
+    offset = end;
+    onProgress?.(offset, fileSize, lineIndex);
+  }
+
+  if (buffer.trim()) {
+    const currentIndex = lineIndex;
+    lineIndex += 1;
+    if (onLine) {
+      await onLine(buffer, currentIndex);
+    }
+  } else if (buffer.length > 0) {
+    skippedEmptyCount++;
+  }
+
+  return { lineCount: lineIndex, skippedEmptyCount };
+}
+
+export async function streamSplitAndUpload(
+  file: File,
+  uploadFn: (formData: FormData, config?: { onUploadProgress?: (e: { loaded: number; total: number }) => void }) => Promise<unknown>,
+  onProgress?: (currentBytes: number, totalBytes: number, uploadedLines: number) => void,
+  chunkSize: number = 1024 * 1024, // 1MB
+  options: StreamUploadOptions
+): Promise<StreamUploadResult> {
+  const {
+    reqId: initialReqId,
+    resolveReqId,
+    onReqIdResolved,
+    fileNamePrefix,
+    prefix,
+    signal,
+    maxConcurrency = 3,
+  } = options;
+
+  const fileSize = file.size;
+  let uploadedCount = 0;
+  let skippedEmptyCount = 0;
+  
+  // 获取文件名基础部分和扩展名
+  const originalFileName = fileNamePrefix || file.name;
+  const lastDotIndex = originalFileName.lastIndexOf(".");
+  const baseName = lastDotIndex > 0 ? originalFileName.slice(0, lastDotIndex) : originalFileName;
+  const fileExtension = lastDotIndex > 0 ? originalFileName.slice(lastDotIndex) : "";
+
+  let resolvedReqId = initialReqId;
+  if (!resolvedReqId) {
+    const scanResult = await processFileLines(file, chunkSize, signal);
+    const totalFileNum = scanResult.lineCount;
+    skippedEmptyCount = scanResult.skippedEmptyCount;
+    if (totalFileNum === 0) {
+      return {
+        uploadedCount: 0,
+        totalBytes: fileSize,
+        skippedEmptyCount,
+      };
+    }
+    if (signal?.aborted) {
+      throw new Error("Upload cancelled");
+    }
+    if (!resolveReqId) {
+      throw new Error("Missing pre-upload request id");
+    }
+    resolvedReqId = await resolveReqId({ totalFileNum, totalSize: fileSize });
+    if (!resolvedReqId) {
+      throw new Error("Failed to resolve pre-upload request id");
+    }
+    onReqIdResolved?.(resolvedReqId);
+  }
+  if (!resolvedReqId) {
+    throw new Error("Missing pre-upload request id");
+  }
+
+  /**
+   * 上传单行内容
+   * 每行作为独立文件上传，fileNo 对应行序号，chunkNo 固定为 1
+   */
+  async function uploadLine(line: string, index: number): Promise<void> {
+    // 检查是否已取消
+    if (signal?.aborted) {
+      throw new Error("Upload cancelled");
+    }
+    
+    if (!line.trim()) {
+      skippedEmptyCount++;
+      return;
+    }
+
+    // 保留原始文件扩展名
+    const fileIndex = index + 1;
+    const newFileName = `${baseName}_${String(fileIndex).padStart(6, "0")}${fileExtension}`;
+    const blob = new Blob([line], { type: "text/plain" });
+    const lineFile = new File([blob], newFileName, { type: "text/plain" });
+    
+    // 计算分片（小文件通常只需要一个分片）
+    const slices = sliceFile(lineFile, DEFAULT_CHUNK_SIZE);
+    const checkSum = await calculateSHA256(slices[0]);
+    
+    // 检查是否已取消（计算哈希后）
+    if (signal?.aborted) {
+      throw new Error("Upload cancelled");
+    }
+    
+    const formData = new FormData();
+    formData.append("file", slices[0]);
+    formData.append("reqId", resolvedReqId.toString());
+    // 每行作为独立文件上传
+    formData.append("fileNo", fileIndex.toString());
+    formData.append("chunkNo", "1");
+    formData.append("fileName", newFileName);
+    formData.append("fileSize", lineFile.size.toString());
+    formData.append("totalChunkNum", "1");
+    formData.append("checkSumHex", checkSum);
+    if (prefix !== undefined) {
+      formData.append("prefix", prefix);
+    }
+
+    await uploadFn(formData, {
+      onUploadProgress: () => {
+        // 单行文件很小，进度主要用于追踪上传状态
+      },
+    });
+  }
+
+  const inFlight = new Set<Promise<void>>();
+  let uploadError: unknown = null;
+  const enqueueUpload = async (line: string, index: number) => {
+    if (signal?.aborted) {
+      throw new Error("Upload cancelled");
+    }
+    if (uploadError) {
+      throw uploadError;
+    }
+    const uploadPromise = uploadLine(line, index)
+      .then(() => {
+        uploadedCount++;
+      })
+      .catch((err) => {
+        uploadError = err;
+      });
+    inFlight.add(uploadPromise);
+    uploadPromise.finally(() => inFlight.delete(uploadPromise));
+    if (inFlight.size >= maxConcurrency) {
+      await Promise.race(inFlight);
+      if (uploadError) {
+        throw uploadError;
+      }
+    }
+  };
+
+  let uploadResult: { lineCount: number; skippedEmptyCount: number } | null = null;
+  try {
+    uploadResult = await processFileLines(
+      file,
+      chunkSize,
+      signal,
+      enqueueUpload,
+      (currentBytes, totalBytes) => {
+        onProgress?.(currentBytes, totalBytes, uploadedCount);
+      }
+    );
+    if (uploadError) {
+      throw uploadError;
+    }
+  } finally {
+    if (inFlight.size > 0) {
+      await Promise.allSettled(inFlight);
+    }
+  }
+
+  if (!uploadResult || (initialReqId && uploadResult.lineCount === 0)) {
+    return {
+      uploadedCount: 0,
+      totalBytes: fileSize,
+      skippedEmptyCount: uploadResult?.skippedEmptyCount ?? 0,
+    };
+  }
+
+  if (!initialReqId) {
+    skippedEmptyCount = skippedEmptyCount || uploadResult.skippedEmptyCount;
+  } else {
+    skippedEmptyCount = uploadResult.skippedEmptyCount;
+  }
+
+  return {
+    uploadedCount,
+    totalBytes: fileSize,
+    skippedEmptyCount,
+  };
+}
+
+/**
+ * 判断文件是否需要流式分割上传
+ * @param file 文件对象
+ * @param threshold 阈值，默认 5MB
+ */
+export function shouldStreamUpload(file: File, threshold: number = 5 * 1024 * 1024): boolean {
+  return file.size > threshold;
+}
--- a/frontend/src/utils/request.ts
+++ b/frontend/src/utils/request.ts
@@ -92,6 +92,14 @@ class Request {
        });
      }

+      // 监听 AbortSignal 来中止请求
+      if (config.signal) {
+        config.signal.addEventListener("abort", () => {
+          xhr.abort();
+          reject(new Error("上传已取消"));
+        });
+      }
+
      // 监听上传进度
      xhr.upload.addEventListener("progress", function (event) {
        if (event.lengthComputable) {
--- a/runtime/datamate-python/app/module/annotation/interface/editor.py
+++ b/runtime/datamate-python/app/module/annotation/interface/editor.py
@@ -20,6 +20,7 @@ from app.module.annotation.schema.editor import (
    EditorProjectInfo,
    EditorTaskListResponse,
    EditorTaskResponse,
+    EditorTaskSegmentsResponse,
    UpsertAnnotationRequest,
    UpsertAnnotationResponse,
 )
@@ -87,6 +88,20 @@ async def get_editor_task(
    return StandardResponse(code=200, message="success", data=task)


+@router.get(
+    "/projects/{project_id}/tasks/{file_id}/segments",
+    response_model=StandardResponse[EditorTaskSegmentsResponse],
+)
+async def list_editor_task_segments(
+    project_id: str = Path(..., description="标注项目ID（t_dm_labeling_projects.id）"),
+    file_id: str = Path(..., description="文件ID（t_dm_dataset_files.id）"),
+    db: AsyncSession = Depends(get_db),
+):
+    service = AnnotationEditorService(db)
+    result = await service.get_task_segments(project_id, file_id)
+    return StandardResponse(code=200, message="success", data=result)
+
+
@router.put(
    "/projects/{project_id}/tasks/{file_id}/annotation",
    response_model=StandardResponse[UpsertAnnotationResponse],
--- a/runtime/datamate-python/app/module/annotation/interface/project.py
+++ b/runtime/datamate-python/app/module/annotation/interface/project.py
@@ -150,6 +150,18 @@ async def create_mapping(
            labeling_project, snapshot_file_ids
        )

+        # 如果启用了分段且为文本数据集，预生成切片结构
+        if dataset_type == TEXT_DATASET_TYPE and request.segmentation_enabled:
+            try:
+                from ..service.editor import AnnotationEditorService
+                editor_service = AnnotationEditorService(db)
+                # 异步预计算切片（不阻塞创建响应）
+                segmentation_result = await editor_service.precompute_segmentation_for_project(labeling_project.id)
+                logger.info(f"Precomputed segmentation for project {labeling_project.id}: {segmentation_result}")
+            except Exception as e:
+                logger.warning(f"Failed to precompute segmentation for project {labeling_project.id}: {e}")
+                # 不影响项目创建，只记录警告
+
        response_data = DatasetMappingCreateResponse(
            id=mapping.id,
            labeling_project_id=str(mapping.labeling_project_id),
--- a/runtime/datamate-python/app/module/annotation/schema/editor.py
+++ b/runtime/datamate-python/app/module/annotation/schema/editor.py
@@ -79,12 +79,9 @@ class EditorTaskListResponse(BaseModel):


 class SegmentInfo(BaseModel):
-    """段落信息（用于文本分段标注）"""
+    """段落摘要（用于文本分段标注）"""

    idx: int = Field(..., description="段落索引")
-    text: str = Field(..., description="段落文本")
-    start: int = Field(..., description="在原文中的起始位置")
-    end: int = Field(..., description="在原文中的结束位置")
    has_annotation: bool = Field(False, alias="hasAnnotation", description="该段落是否已有标注")
    line_index: int = Field(0, alias="lineIndex", description="JSONL 行索引（从0开始）")
    chunk_index: int = Field(0, alias="chunkIndex", description="行内分片索引（从0开始）")
@@ -100,13 +97,22 @@ class EditorTaskResponse(BaseModel):

    # 分段相关字段
    segmented: bool = Field(False, description="是否启用分段模式")
-    segments: Optional[List[SegmentInfo]] = Field(None, description="段落列表")
    total_segments: int = Field(0, alias="totalSegments", description="总段落数")
    current_segment_index: int = Field(0, alias="currentSegmentIndex", description="当前段落索引")

    model_config = ConfigDict(populate_by_name=True)


+class EditorTaskSegmentsResponse(BaseModel):
+    """编辑器段落摘要响应"""
+
+    segmented: bool = Field(False, description="是否启用分段模式")
+    segments: List[SegmentInfo] = Field(default_factory=list, description="段落摘要列表")
+    total_segments: int = Field(0, alias="totalSegments", description="总段落数")
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
 class UpsertAnnotationRequest(BaseModel):
    """保存/覆盖最终标注（Label Studio annotation 原始对象）"""

--- a/runtime/datamate-python/app/module/annotation/service/editor.py
+++ b/runtime/datamate-python/app/module/annotation/service/editor.py
@@ -37,6 +37,7 @@ from app.module.annotation.schema.editor import (
    EditorTaskListItem,
    EditorTaskListResponse,
    EditorTaskResponse,
+    EditorTaskSegmentsResponse,
    SegmentInfo,
    UpsertAnnotationRequest,
    UpsertAnnotationResponse,
@@ -538,6 +539,49 @@ class AnnotationEditorService:
                return value
        return raw_text

+    def _build_segment_contexts(
+        self,
+        records: List[Tuple[Optional[Dict[str, Any]], str]],
+        record_texts: List[str],
+        segment_annotation_keys: set[str],
+    ) -> Tuple[List[SegmentInfo], List[Tuple[Optional[Dict[str, Any]], str, str, int, int]]]:
+        splitter = AnnotationTextSplitter(max_chars=self.SEGMENT_THRESHOLD)
+        segment_contexts: List[Tuple[Optional[Dict[str, Any]], str, str, int, int]] = []
+        segment_cursor = 0
+
+        for record_index, ((payload, raw_text), record_text) in enumerate(zip(records, record_texts)):
+            normalized_text = record_text or ""
+            if len(normalized_text) > self.SEGMENT_THRESHOLD:
+                raw_segments = splitter.split(normalized_text)
+                for chunk_index, seg in enumerate(raw_segments):
+                    segments.append(
+                        SegmentInfo(
+                            idx=segment_cursor,
+                            hasAnnotation=str(segment_cursor) in segment_annotation_keys,
+                            lineIndex=record_index,
+                            chunkIndex=chunk_index,
+                        )
+                    )
+                    segment_contexts.append((payload, raw_text, seg["text"], record_index, chunk_index))
+                    segment_cursor += 1
+            else:
+                segments.append(
+                    SegmentInfo(
+                        idx=segment_cursor,
+                        hasAnnotation=str(segment_cursor) in segment_annotation_keys,
+                        lineIndex=record_index,
+                        chunkIndex=0,
+                    )
+                )
+                segment_contexts.append((payload, raw_text, normalized_text, record_index, 0))
+                segment_cursor += 1
+
+        if not segments:
+            segments = [SegmentInfo(idx=0, hasAnnotation=False, lineIndex=0, chunkIndex=0)]
+            segment_contexts = [(None, "", "", 0, 0)]
+
+        return segments, segment_contexts
+
    async def get_project_info(self, project_id: str) -> EditorProjectInfo:
        project = await self._get_project_or_404(project_id)

@@ -668,6 +712,87 @@ class AnnotationEditorService:

        return await self._build_text_task(project, file_record, file_id, segment_index)

+    async def get_task_segments(
+        self,
+        project_id: str,
+        file_id: str,
+    ) -> EditorTaskSegmentsResponse:
+        project = await self._get_project_or_404(project_id)
+
+        dataset_type = self._normalize_dataset_type(await self._get_dataset_type(project.dataset_id))
+        if dataset_type != DATASET_TYPE_TEXT:
+            raise HTTPException(
+                status_code=400,
+                detail="当前仅支持 TEXT 项目的段落摘要",
+            )
+
+        file_result = await self.db.execute(
+            select(DatasetFiles).where(
+                DatasetFiles.id == file_id,
+                DatasetFiles.dataset_id == project.dataset_id,
+            )
+        )
+        file_record = file_result.scalar_one_or_none()
+        if not file_record:
+            raise HTTPException(status_code=404, detail=f"文件不存在或不属于该项目: {file_id}")
+
+        if not self._resolve_segmentation_enabled(project):
+            return EditorTaskSegmentsResponse(segmented=False, segments=[], totalSegments=0)
+
+        text_content = await self._fetch_text_content_via_download_api(project.dataset_id, file_id)
+        assert isinstance(text_content, str)
+        label_config = await self._resolve_project_label_config(project)
+        primary_text_key = self._resolve_primary_text_key(label_config)
+        file_name = str(getattr(file_record, "file_name", "")).lower()
+
+        records: List[Tuple[Optional[Dict[str, Any]], str]] = []
+        if file_name.endswith(JSONL_EXTENSION):
+            records = self._parse_jsonl_records(text_content)
+        else:
+            parsed_payload = self._try_parse_json_payload(text_content)
+            if parsed_payload:
+                records = [(parsed_payload, text_content)]
+
+        if not records:
+            records = [(None, text_content)]
+
+        record_texts = [
+            self._resolve_primary_text_value(payload, raw_text, primary_text_key)
+            for payload, raw_text in records
+        ]
+        if not record_texts:
+            record_texts = [text_content]
+
+        needs_segmentation = len(records) > 1 or any(
+            len(text or "") > self.SEGMENT_THRESHOLD for text in record_texts
+        )
+        if not needs_segmentation:
+            return EditorTaskSegmentsResponse(segmented=False, segments=[], totalSegments=0)
+
+        ann_result = await self.db.execute(
+            select(AnnotationResult).where(
+                AnnotationResult.project_id == project.id,
+                AnnotationResult.file_id == file_id,
+            )
+        )
+        ann = ann_result.scalar_one_or_none()
+        segment_annotations: Dict[str, Dict[str, Any]] = {}
+        if ann and isinstance(ann.annotation, dict):
+            segment_annotations = self._extract_segment_annotations(ann.annotation)
+        segment_annotation_keys = set(segment_annotations.keys())
+
+        segments, _ = self._build_segment_contexts(
+            records,
+            record_texts,
+            segment_annotation_keys,
+        )
+
+        return EditorTaskSegmentsResponse(
+            segmented=True,
+            segments=segments,
+            totalSegments=len(segments),
+        )
+
    async def _build_text_task(
        self,
        project: LabelingProject,
@@ -723,7 +848,8 @@ class AnnotationEditorService:
        needs_segmentation = segmentation_enabled and (
            len(records) > 1 or any(len(text or "") > self.SEGMENT_THRESHOLD for text in record_texts)
        )
-        segments: Optional[List[SegmentInfo]] = None
+        segments: List[SegmentInfo] = []
+        segment_contexts: List[Tuple[Optional[Dict[str, Any]], str, str, int, int]] = []
        current_segment_index = 0
        display_text = record_texts[0] if record_texts else text_content
        selected_payload = records[0][0] if records else None
@@ -732,46 +858,13 @@ class AnnotationEditorService:
            display_text = "\n".join(record_texts) if record_texts else text_content

        if needs_segmentation:
-            splitter = AnnotationTextSplitter(max_chars=self.SEGMENT_THRESHOLD)
-            segment_contexts: List[Tuple[Optional[Dict[str, Any]], str, str, int, int]] = []
-            segments = []
-            segment_cursor = 0
-
-            for record_index, ((payload, raw_text), record_text) in enumerate(zip(records, record_texts)):
-                normalized_text = record_text or ""
-                if len(normalized_text) > self.SEGMENT_THRESHOLD:
-                    raw_segments = splitter.split(normalized_text)
-                    for chunk_index, seg in enumerate(raw_segments):
-                        segments.append(SegmentInfo(
-                            idx=segment_cursor,
-                            text=seg["text"],
-                            start=seg["start"],
-                            end=seg["end"],
-                            hasAnnotation=str(segment_cursor) in segment_annotation_keys,
-                            lineIndex=record_index,
-                            chunkIndex=chunk_index,
-                        ))
-                        segment_contexts.append((payload, raw_text, seg["text"], record_index, chunk_index))
-                        segment_cursor += 1
-                else:
-                    segments.append(SegmentInfo(
-                        idx=segment_cursor,
-                        text=normalized_text,
-                        start=0,
-                        end=len(normalized_text),
-                        hasAnnotation=str(segment_cursor) in segment_annotation_keys,
-                        lineIndex=record_index,
-                        chunkIndex=0,
-                    ))
-                    segment_contexts.append((payload, raw_text, normalized_text, record_index, 0))
-                    segment_cursor += 1
-
-            if not segments:
-                segments = [SegmentInfo(idx=0, text="", start=0, end=0, hasAnnotation=False, lineIndex=0, chunkIndex=0)]
-                segment_contexts = [(None, "", "", 0, 0)]
-
+            _, segment_contexts = self._build_segment_contexts(
+                records,
+                record_texts,
+                segment_annotation_keys,
+            )
            current_segment_index = segment_index if segment_index is not None else 0
-            if current_segment_index < 0 or current_segment_index >= len(segments):
+            if current_segment_index < 0 or current_segment_index >= len(segment_contexts):
                current_segment_index = 0

            selected_payload, _, display_text, _, _ = segment_contexts[current_segment_index]
@@ -849,8 +942,7 @@ class AnnotationEditorService:
            task=task,
            annotationUpdatedAt=annotation_updated_at,
            segmented=needs_segmentation,
-            segments=segments,
-            totalSegments=len(segments) if segments else 1,
+            totalSegments=len(segment_contexts) if needs_segmentation else 1,
            currentSegmentIndex=current_segment_index,
        )

@@ -1185,3 +1277,195 @@ class AnnotationEditorService:
        except Exception as exc:
            logger.warning("标注同步知识管理失败：%s", exc)

+    async def precompute_segmentation_for_project(
+        self,
+        project_id: str,
+        max_retries: int = 3
+    ) -> Dict[str, Any]:
+        """
+        为指定项目的所有文本文件预计算切片结构并持久化到数据库
+
+        Args:
+            project_id: 标注项目ID
+            max_retries: 失败重试次数
+
+        Returns:
+            统计信息：{total_files, succeeded, failed}
+        """
+        project = await self._get_project_or_404(project_id)
+        dataset_type = self._normalize_dataset_type(await self._get_dataset_type(project.dataset_id))
+
+        # 只处理文本数据集
+        if dataset_type != DATASET_TYPE_TEXT:
+            logger.info(f"项目 {project_id} 不是文本数据集，跳过切片预生成")
+            return {"total_files": 0, "succeeded": 0, "failed": 0}
+
+        # 检查是否启用分段
+        if not self._resolve_segmentation_enabled(project):
+            logger.info(f"项目 {project_id} 未启用分段，跳过切片预生成")
+            return {"total_files": 0, "succeeded": 0, "failed": 0}
+
+        # 获取项目的所有文本文件（排除源文档）
+        files_result = await self.db.execute(
+            select(DatasetFiles)
+            .join(LabelingProjectFile, LabelingProjectFile.file_id == DatasetFiles.id)
+            .where(
+                LabelingProjectFile.project_id == project_id,
+                DatasetFiles.dataset_id == project.dataset_id,
+            )
+        )
+        file_records = files_result.scalars().all()
+
+        if not file_records:
+            logger.info(f"项目 {project_id} 没有文件，跳过切片预生成")
+            return {"total_files": 0, "succeeded": 0, "failed": 0}
+
+        # 过滤源文档文件
+        valid_files = []
+        for file_record in file_records:
+            file_type = str(getattr(file_record, "file_type", "") or "").lower()
+            file_name = str(getattr(file_record, "file_name", "")).lower()
+            is_source_document = (
+                file_type in SOURCE_DOCUMENT_TYPES or
+                any(file_name.endswith(ext) for ext in SOURCE_DOCUMENT_EXTENSIONS)
+            )
+            if not is_source_document:
+                valid_files.append(file_record)
+
+        total_files = len(valid_files)
+        succeeded = 0
+        failed = 0
+
+        label_config = await self._resolve_project_label_config(project)
+        primary_text_key = self._resolve_primary_text_key(label_config)
+
+        for file_record in valid_files:
+            file_id = str(file_record.id)  # type: ignore
+            file_name = str(getattr(file_record, "file_name", ""))
+
+            for retry in range(max_retries):
+                try:
+                    # 读取文本内容
+                    text_content = await self._fetch_text_content_via_download_api(project.dataset_id, file_id)
+                    if not isinstance(text_content, str):
+                        logger.warning(f"文件 {file_id} 内容不是字符串，跳过切片")
+                        failed += 1
+                        break
+
+                    # 解析文本记录
+                    records: List[Tuple[Optional[Dict[str, Any]], str]] = []
+                    if file_name.lower().endswith(JSONL_EXTENSION):
+                        records = self._parse_jsonl_records(text_content)
+                    else:
+                        parsed_payload = self._try_parse_json_payload(text_content)
+                        if parsed_payload:
+                            records = [(parsed_payload, text_content)]
+
+                    if not records:
+                        records = [(None, text_content)]
+
+                    record_texts = [
+                        self._resolve_primary_text_value(payload, raw_text, primary_text_key)
+                        for payload, raw_text in records
+                    ]
+                    if not record_texts:
+                        record_texts = [text_content]
+
+                    # 判断是否需要分段
+                    needs_segmentation = len(records) > 1 or any(
+                        len(text or "") > self.SEGMENT_THRESHOLD for text in record_texts
+                    )
+
+                    if not needs_segmentation:
+                        # 不需要分段的文件，跳过
+                        succeeded += 1
+                        break
+
+                    # 执行切片
+                    splitter = AnnotationTextSplitter(max_chars=self.SEGMENT_THRESHOLD)
+                    segment_cursor = 0
+                    segments = {}
+
+                    for record_index, ((payload, raw_text), record_text) in enumerate(zip(records, record_texts)):
+                        normalized_text = record_text or ""
+
+                        if len(normalized_text) > self.SEGMENT_THRESHOLD:
+                            raw_segments = splitter.split(normalized_text)
+                            for chunk_index, seg in enumerate(raw_segments):
+                                segments[str(segment_cursor)] = {
+                                    SEGMENT_RESULT_KEY: [],
+                                    SEGMENT_CREATED_AT_KEY: datetime.utcnow().isoformat() + "Z",
+                                    SEGMENT_UPDATED_AT_KEY: datetime.utcnow().isoformat() + "Z",
+                                }
+                                segment_cursor += 1
+                        else:
+                            segments[str(segment_cursor)] = {
+                                SEGMENT_RESULT_KEY: [],
+                                SEGMENT_CREATED_AT_KEY: datetime.utcnow().isoformat() + "Z",
+                                SEGMENT_UPDATED_AT_KEY: datetime.utcnow().isoformat() + "Z",
+                            }
+                            segment_cursor += 1
+
+                    if not segments:
+                        succeeded += 1
+                        break
+
+                    # 构造分段标注结构
+                    final_payload = {
+                        SEGMENTED_KEY: True,
+                        "version": 1,
+                        SEGMENTS_KEY: segments,
+                        SEGMENT_TOTAL_KEY: segment_cursor,
+                    }
+
+                    # 检查是否已存在标注
+                    existing_result = await self.db.execute(
+                        select(AnnotationResult).where(
+                            AnnotationResult.project_id == project_id,
+                            AnnotationResult.file_id == file_id,
+                        )
+                    )
+                    existing = existing_result.scalar_one_or_none()
+
+                    now = datetime.utcnow()
+
+                    if existing:
+                        # 更新现有标注
+                        existing.annotation = final_payload  # type: ignore[assignment]
+                        existing.annotation_status = ANNOTATION_STATUS_IN_PROGRESS  # type: ignore[assignment]
+                        existing.updated_at = now  # type: ignore[assignment]
+                    else:
+                        # 创建新标注记录
+                        record = AnnotationResult(
+                            id=str(uuid.uuid4()),
+                            project_id=project_id,
+                            file_id=file_id,
+                            annotation=final_payload,
+                            annotation_status=ANNOTATION_STATUS_IN_PROGRESS,
+                            created_at=now,
+                            updated_at=now,
+                        )
+                        self.db.add(record)
+
+                    await self.db.commit()
+                    succeeded += 1
+                    logger.info(f"成功为文件 {file_id} 预生成 {segment_cursor} 个切片")
+                    break
+
+                except Exception as e:
+                    logger.warning(
+                        f"为文件 {file_id} 预生成切片失败 (重试 {retry + 1}/{max_retries}): {e}"
+                    )
+                    if retry == max_retries - 1:
+                        failed += 1
+                        await self.db.rollback()
+
+        logger.info(
+            f"项目 {project_id} 切片预生成完成: 总计 {total_files}, 成功 {succeeded}, 失败 {failed}"
+        )
+        return {
+            "total_files": total_files,
+            "succeeded": succeeded,
+            "failed": failed,
+        }
+
Author	SHA1	Message	Date
Jerry Yan	cda22a720c	feat(annotation): 优化文本标注分段功能实现 - 新增 getEditorTaskSegmentsUsingGet 接口用于获取任务分段信息 - 移除 SegmentInfo 中的 text、start、end 字段，精简数据结构 - 添加 EditorTaskSegmentsResponse 类型定义用于分段摘要响应 - 实现服务端 get_task_segments 方法，支持分段信息查询 - 重构前端组件缓存机制，使用 segmentSummaryFileRef 管理分段状态 - 优化分段构建逻辑，提取 _build_segment_contexts 公共方法 - 调整后端 _build_text_task 方法中的分段处理流程 - 更新 API 类型定义，统一 RequestParams 和 RequestPayload 类型	2026-02-04 16:59:04 +08:00
Jerry Yan	394e2bda18	feat(data-management): 添加数据集文件取消上传功能 - 在OpenAPI规范中定义了取消上传的REST端点接口 - 实现了DatasetFileApplicationService中的取消上传业务逻辑 - 在FileService中添加了完整的取消上传服务方法 - 创建了DatasetUploadController控制器处理取消上传请求 - 实现了临时分片文件清理和数据库记录删除功能	2026-02-04 16:25:03 +08:00
Jerry Yan	4220284f5a	refactor(utils): 重构文件流式分割上传功能 - 将 streamSplitAndUpload 函数拆分为独立的 processFileLines 函数 - 简化文件按行处理逻辑，移除冗余的行收集和缓存机制 - 优化并发上传实现，使用 Promise 集合管理上传任务 - 修复上传过程中断信号处理和错误传播机制 - 统一进度回调参数结构，改进字节和行数跟踪逻辑 - 优化空行跳过计数和上传结果返回值处理	2026-02-04 16:11:03 +08:00
Jerry Yan	8415166949	refactor(upload): 重构切片上传逻辑支持动态请求ID解析 - 移除预先批量获取reqId的方式，改为按需解析 - 新增resolveReqId函数支持动态获取请求ID - 添加onReqIdResolved回调处理ID解析完成事件 - 改进文件按行切片上传，每行作为独立文件处理 - 优化空行跳过逻辑，统计跳过的空行数量 - 修复fileNo和chunkNo的对应关系 - 更新streamSplitAndUpload参数结构	2026-02-04 15:58:58 +08:00
Jerry Yan	078f303f57	Revert "fix: 修复 hasArchive 和 splitByLine 同时存在的问题" This reverts commit `50f2da5503`.	2026-02-04 15:48:01 +08:00
Jerry Yan	50f2da5503	fix: 修复 hasArchive 和 splitByLine 同时存在的问题问题：hasArchive 默认为 true，而 splitByLine 可以与其同时开启，导致压缩包被错误地按行分割，产生逻辑矛盾。修复： 1. 当 hasArchive=true 时，禁用 splitByLine switch 2. 添加 useEffect，当 hasArchive 变为 true 时自动关闭 splitByLine 修改文件：frontend/src/pages/DataManagement/Detail/components/ImportConfiguration.tsx	2026-02-04 15:43:53 +08:00
Jerry Yan	3af1daf8b6	fix: 修复流式分割上传的"预上传请求不存在"错误问题：handleStreamUpload 中为所有文件只调用一次 preUpload，设置 totalFileNum: files.length（原始文件数），但实际上传的文件数量是按行分割后的总行数，导致后端提前删除预上传请求。修复：将 preUpload 调用移到文件循环内部，为每个原始文件单独调用 preUpload，设置 totalFileNum: 1，每个文件有自己的 reqId。这样可以避免按行分割导致的请求被提前删除问题。修改文件：frontend/src/hooks/useSliceUpload.tsx	2026-02-04 15:39:05 +08:00
Jerry Yan	7c7729434b	fix: 修复流式分割上传的三个问题 1. 实现真正的并发控制，避免同时产生大量请求 - 使用任务队列模式，确保同时运行的任务不超过 maxConcurrency - 完成一个任务后才启动下一个，而不是一次性启动所有任务 2. 修复 API 错误（预上传请求不存在） - 所有分片使用相同的 fileNo=1（属于同一个预上传请求） - chunkNo 改为行号，表示第几行数据 - 这是根本原因：之前每行都被当作不同文件，但只有第一个文件有有效的预上传请求 3. 保留原始文件扩展名 - 正确提取并保留文件扩展名 - 例如：132.txt → 132_000001.txt（而不是 132_000001）	2026-02-04 15:06:02 +08:00
Jerry Yan	17a62cd3c2	fix: 修复上传取消功能，确保 HTTP 请求正确中止 - 在 XMLHttpRequest 中添加 signal.aborted 检查 - 修复 useSliceUpload 中的 cancelFn 闭包问题 - 确保流式上传和分片上传都能正确取消	2026-02-04 14:51:23 +08:00
Jerry Yan	f381d641ab	fix(upload): 修复流式上传中的文件名处理逻辑 - 修正预上传接口调用时传递正确的文件总数而非固定值-1 - 移除导入配置中文件分割时的文件扩展名保留逻辑 - 删除流式上传选项中的fileExtension参数定义 - 移除流式上传实现中的文件扩展名处理相关代码 - 简化新文件名生成逻辑，不再附加扩展名后缀	2026-02-04 07:47:41 +08:00
Jerry Yan	c8611d29ff	feat(upload): 实现流式分割上传，优化大文件上传体验实现边分割边上传的流式处理，避免大文件一次性加载导致前端卡顿。修改内容： 1. file.util.ts - 流式分割上传核心功能 - 新增 streamSplitAndUpload 函数，实现边分割边上传 - 新增 shouldStreamUpload 函数，判断是否使用流式上传 - 新增 StreamUploadOptions 和 StreamUploadResult 接口 - 优化分片大小（默认 5MB） 2. ImportConfiguration.tsx - 智能上传策略 - 大文件（>5MB）使用流式分割上传 - 小文件（≤5MB）使用传统分割方式 - 保持 UI 不变 3. useSliceUpload.tsx - 流式上传处理 - 新增 handleStreamUpload 处理流式上传事件 - 支持并发上传和更好的进度管理 4. TaskUpload.tsx - 进度显示优化 - 注册流式上传事件监听器 - 显示流式上传信息（已上传行数、当前文件等） 5. dataset.model.ts - 类型定义扩展 - 新增 StreamUploadInfo 接口 - TaskItem 接口添加 streamUploadInfo 和 prefix 字段实现特点： - 流式读取：使用 Blob.slice 逐块读取，避免一次性加载 - 逐行检测：按换行符分割，形成完整行后立即上传 - 内存优化：buffer 只保留当前块和未完成行，不累积所有分割结果 - 并发控制：支持 3 个并发上传，提升效率 - 进度可见：实时显示已上传行数和总体进度 - 错误处理：单个文件上传失败不影响其他文件 - 向后兼容：小文件仍使用原有分割方式优势： - 大文件上传不再卡顿，用户体验大幅提升 - 内存占用显著降低（从加载整个文件到只保留当前块） - 上传效率提升（边分割边上传，并发上传多个小文件）相关文件： - frontend/src/utils/file.util.ts - frontend/src/pages/DataManagement/Detail/components/ImportConfiguration.tsx - frontend/src/hooks/useSliceUpload.tsx - frontend/src/pages/Layout/TaskUpload.tsx - frontend/src/pages/DataManagement/dataset.model.ts	2026-02-03 13:12:10 +00:00
Jerry Yan	147beb1ec7	feat(annotation): 实现文本切片预生成功能在创建标注任务时自动预生成文本切片结构，避免每次进入标注页面时的实时计算。修改内容： 1. 在 AnnotationEditorService 中新增 precompute_segmentation_for_project 方法 - 为项目的所有文本文件预计算切片结构 - 使用 AnnotationTextSplitter 执行切片 - 将切片结构持久化到 AnnotationResult 表（状态为 IN_PROGRESS） - 支持失败重试机制 - 返回统计信息 2. 修改 create_mapping 接口 - 在创建标注任务后，如果启用分段且为文本数据集，自动触发切片预生成 - 使用 try-except 捕获异常，确保切片失败不影响项目创建特点： - 使用现有的 AnnotationTextSplitter 类 - 切片数据结构与现有分段标注格式一致 - 向后兼容（未切片的任务仍然使用实时计算） - 性能优化：避免进入标注页面时的重复计算相关文件： - runtime/datamate-python/app/module/annotation/service/editor.py - runtime/datamate-python/app/module/annotation/interface/project.py	2026-02-03 12:59:29 +00:00
Jerry Yan	699031dae7	fix: 修复编辑数据集时无法清除关联数据集的编译问题问题分析：之前尝试使用 @TableField(updateStrategy = FieldStrategy.IGNORED/ALWAYS) 注解来强制更新 null 值，但 FieldStrategy.ALWAYS 可能不存在于当前 MyBatis-Plus 3.5.14 版本中，导致编译错误。修复方案： 1. 移除 Dataset.java 中 parentDatasetId 字段的 @TableField(updateStrategy) 注解 2. 移除不需要的 import com.baomidou.mybatisplus.annotation.FieldStrategy 3. 在 DatasetApplicationService.updateDataset 方法中： - 添加 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper - 保存原始的 parentDatasetId 值用于比较 - handleParentChange 之后，检查 parentDatasetId 是否发生变化 - 如果发生变化，使用 LambdaUpdateWrapper 显式地更新 parentDatasetId 字段 - 这样即使值为 null 也能被正确更新到数据库原理： MyBatis-Plus 的 updateById 方法默认只更新非 null 字段。通过使用 LambdaUpdateWrapper 的 set 方法，可以显式地设置字段值，包括 null 值，从而确保字段能够被正确更新到数据库。	2026-02-03 11:09:15 +00:00
Jerry Yan	88b1383653	fix: 恢复前端发送空字符串以支持清除关联数据集修改说明：移除了之前将空字符串转换为 undefined 的逻辑，现在直接发送表单值，包括空字符串。配合后端修改（commit cc6415c）： 1. 当用户选择"无关联数据集"时，发送空字符串 "" 2. 后端 handleParentChange 方法通过 normalizeParentId 将空字符串转为 null 3. Dataset.parentDatasetId 字段添加了 @TableField(updateStrategy = FieldStrategy.IGNORED) 4. 确保即使值为 null 也会被更新到数据库	2026-02-03 10:57:14 +00:00
Jerry Yan	cc6415c4d9	fix: 修复编辑数据集时无法清除关联数据集的问题问题描述：在数据管理的数据集编辑中，如果之前设置了关联数据集，编辑时选择不关联数据集后保存不会生效。根本原因： MyBatis-Plus 的 updateById 方法默认使用 FieldStrategy.NOT_NULL 策略，只有当字段值为非 null 时才会更新到数据库。当 parentDatasetId 从有值变为 null 时，默认情况下不会更新到数据库。修复方案：在 Dataset.java 的 parentDatasetId 字段上添加 @TableField(updateStrategy = FieldStrategy.IGNORED) 注解，表示即使值为 null 也需要更新到数据库。配合前端修改（恢复发送空字符串），现在可以正确清除关联数据集： 1. 前端发送空字符串表示"无关联数据集" 2. 后端 handleParentChange 通过 normalizeParentId 将空字符串转为 null 3. dataset.setParentDatasetId(null) 设置为 null 4. 由于添加了 IGNORED 策略，即使为 null 也会更新到数据库	2026-02-03 10:57:08 +00:00
Jerry Yan	3d036c4cd6	fix: 修复编辑数据集时无法清除关联数据集的问题问题描述：在数据管理的数据集编辑中，如果之前设置了关联数据集，编辑时选择不关联数据集后保存不会生效。问题原因：后端 updateDataset 方法中的条件判断： ```java if (updateDatasetRequest.getParentDatasetId() != null) { handleParentChange(dataset, updateDatasetRequest.getParentDatasetId()); } ``` 当 parentDatasetId 为 null 或空字符串时，条件判断为 false，不会执行 handleParentChange，导致无法清除关联数据集。修复方案：去掉条件判断，始终调用 handleParentChange。handleParentChange 内部通过 normalizeParentId 方法将空字符串和 null 都转换为 null，这样既支持设置新的父数据集，也支持清除关联。配合前端修改（commit 2445235），将空字符串转换为 undefined（被后端反序列化为 null），确保清除关联的操作能够正确执行。	2026-02-03 09:35:09 +00:00
Jerry Yan	2445235fd2	fix: 修复编辑数据集时清除关联数据集不生效的问题问题描述：在数据管理的数据集编辑中，如果之前设置了关联数据集，编辑时选择不关联数据集后保存不会生效。问题原因： - BasicInformation.tsx中，"无关联数据集"选项的值是空字符串"" - 当用户选择不关联数据集时，parentDatasetId的值为"" - 后端API将空字符串视为无效值而忽略，而不是识别为"清除关联"的操作修复方案： - 在EditDataset.tsx的handleSubmit函数中，将parentDatasetId的空字符串转换为undefined - 使用 formValues.parentDatasetId \|\| undefined 确保空字符串被转换为 undefined - 这样后端API能正确识别为要清除关联数据集的操作	2026-02-03 09:23:13 +00:00
Jerry Yan	893e0a1580	fix: 上传文件时任务中心立即显示问题描述：在数据管理的数据集详情页上传文件时，点击确认后，弹窗消失，但是需要等待文件处理（特别是启用按行分割时）后任务中心才弹出来，用户体验不好。修改内容： 1. useSliceUpload.tsx: 在 createTask 函数中添加立即显示任务中心的逻辑，确保任务创建后立即显示 2. ImportConfiguration.tsx: 在 handleImportData 函数中，在执行耗时的文件处理操作（如文件分割）之前，立即触发 show:task-popover 事件显示任务中心效果： - 修改前：点击确认 → 弹窗消失 → （等待文件处理）→ 任务中心弹出 - 修改后：点击确认 → 弹窗消失 + 任务中心立即弹出 → 文件开始处理	2026-02-03 09:14:40 +00:00